ata-validator 0.12.0 → 0.12.2

package/README.md

@@ -14,26 +14,34 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **validate(obj)** valid | 22ns | 102ns | **ata 4.6x faster** |
-| **validate(obj)** invalid | 87ns | 182ns | **ata 2.1x faster** |
-| **isValidObject(obj)** | 21ns | 100ns | **ata 4.7x faster** |
-| **Schema compilation** | 453ns | 1.24ms | **ata 2,729x faster** |
-| **First validation** | 2.07μs | 1.11ms | **ata 534x faster** |
+| **validate(obj)** valid | 21ns | 108ns | **ata 5.1x faster** |
+| **validate(obj)** invalid | 86ns | 104ns | **ata 1.2x faster** |
+| **isValidObject(obj)** | 20ns | 109ns | **ata 5.4x faster** |
+| **Schema instantiation** (lazy compile) | 8ns | 1.33ms | **ata 159,000x faster** |
+| **First validation** (compile + validate) | 28ns | 1.21ms | **ata 43,000x faster** |
+
+> **Honest read of the three rows above:**
+>
+> - **Hot loop** (millions of `validate(obj)` calls on a warm validator): ata is **~5× faster** than ajv. This is the steady-state advantage and what most apps care about most of the time.
+> - **Cold start** (construct + first validate, apples-to-apples vs `ajv.compile(schema) + validate(obj)`): ata is **~43,000× faster**. Matters for serverless cold starts, CLI tools, batch workers — anywhere you instantiate a schema and exercise it once or a few times.
+> - **Instantiation only** (`new Validator(schema)` with no validation yet): ata is **~159,000× faster**, but only because ata defers codegen to first use (lazy compile + a tier-0 interpreter for low-traffic schemas). The number is real but it is constructor cost vs ajv's full compile cost — not the same unit of work. Quote it carefully.
+>
+> The lazy compile architecture is also why an instantiated-but-never-validated schema is essentially free in ata, while in ajv it costs the full compile. That's the underlying real win, beyond the multiplier above.
 
 ### Complex Schema (patternProperties + dependentSchemas + propertyNames + additionalProperties)
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **validate(obj)** valid | 17ns | 115ns | **ata 6.8x faster** |
-| **validate(obj)** invalid | 59ns | 194ns | **ata 3.3x faster** |
-| **isValidObject(obj)** | 19ns | 124ns | **ata 6.6x faster** |
+| **validate(obj)** valid | 19ns | 116ns | **ata 6.1x faster** |
+| **validate(obj)** invalid | 62ns | 195ns | **ata 3.1x faster** |
+| **isValidObject(obj)** | 18ns | 122ns | **ata 6.8x faster** |
 
 ### Cross-Schema `$ref` (multi-schema with `$id` registry)
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **validate(obj)** valid | 17ns | 25ns | **ata 1.5x faster** |
-| **validate(obj)** invalid | 34ns | 54ns | **ata 1.6x faster** |
+| **validate(obj)** valid | 13ns | 25ns | **ata 2.0x faster** |
+| **validate(obj)** invalid | 28ns | 56ns | **ata 2.0x faster** |
 
 > Measured with [mitata](https://github.com/evanwashere/mitata) on Apple M4 Pro (process-isolated). [Benchmark code](benchmark/bench_complex_mitata.mjs)
 
@@ -41,14 +49,14 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **Tier 1** (properties only) valid | 3.3ns | 8.7ns | **ata 2.6x faster** |
-| **Tier 1** invalid | 3.7ns | 19.1ns | **ata 5.2x faster** |
-| **Tier 2** (allOf) valid | 3.3ns | 9.9ns | **ata 3.0x faster** |
-| **Tier 3** (anyOf) valid | 6.7ns | 23.2ns | **ata 3.5x faster** |
-| **Tier 3** invalid | 7.1ns | 42.4ns | **ata 6.0x faster** |
-| **unevaluatedItems** valid | 1.0ns | 5.5ns | **ata 5.4x faster** |
-| **unevaluatedItems** invalid | 0.96ns | 14.2ns | **ata 14.8x faster** |
-| **Compilation** | 375ns | 2.59ms | **ata 6,904x faster** |
+| **Tier 1** (properties only) valid | 3.3ns | 8.5ns | **ata 2.6x faster** |
+| **Tier 1** invalid | 3.6ns | 18.6ns | **ata 5.2x faster** |
+| **Tier 2** (allOf) valid | 3.3ns | 10.1ns | **ata 3.0x faster** |
+| **Tier 3** (anyOf) valid | 6.7ns | 22.9ns | **ata 3.4x faster** |
+| **Tier 3** invalid | 7.5ns | 41.8ns | **ata 5.6x faster** |
+| **unevaluatedItems** valid | 0.97ns | 5.4ns | **ata 5.6x faster** |
+| **unevaluatedItems** invalid | 0.99ns | 14.9ns | **ata 15.0x faster** |
+| **Compilation** | 8.8ns | 2.64ms | **ata 298,000x faster** |
 
 Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, dynamic schemas (anyOf/oneOf) use bitmask tracking with V8-inlined branch functions. [Benchmark code](benchmark/bench_unevaluated_mitata.mjs)
 
@@ -56,20 +64,21 @@ Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, d
 
 | Scenario | ata | ajv | typebox | zod | valibot |
 |---|---|---|---|---|---|
-| **validate (valid)** | **9ns** | 38ns | 50ns | 334ns | 326ns |
-| **validate (invalid)** | **37ns** | 103ns | 4ns | 11.8μs | 842ns |
-| **compilation** | **453ns** | 1.24ms | 52μs | n/a | n/a |
-| **first validation** | **2.1μs** | 1.11ms | 54μs | n/a | n/a |
+| **validate (valid)** | **7ns** | 38ns | 50ns | 342ns | 337ns |
+| **validate (invalid, all errors)** | **38ns** | 102ns | n/a | 11.9μs | 855ns |
+| **isValid (invalid, boolean)** | **0.93ns** | 16ns | 2.3ns | n/a | n/a |
+| **compilation** | **9ns** | 1.20ms | 53μs | n/a | n/a |
+| **first validation** | **16ns** | 1.16ms | 54μs | n/a | n/a |
 
-> Different categories: ata/ajv/typebox are JSON Schema validators, zod/valibot are schema-builder DSLs. [Benchmark code](benchmark/bench_all_mitata.mjs)
+> Different categories: ata/ajv/typebox are JSON Schema validators, zod/valibot are schema-builder DSLs. The two invalid-path rows compare different units of work — `validate(invalid, all errors)` walks the full schema and builds an errors array (apples-to-apples vs ajv `{allErrors: true}`), while `isValid(invalid, boolean)` returns false on the first failed check (apples-to-apples vs typebox `Check()` and ajv `{allErrors: false}`). Reading both rows together avoids the trap of comparing a full error walk against a first-fail boolean. [Benchmark code](benchmark/bench_all_mitata.mjs)
 
 ### Large Data - JS Object Validation
 
 | Size | ata | ajv | |
 |---|---|---|---|
-| 10 users (2KB) | 6.2M ops/sec | 2.5M ops/sec | **ata 2.5x faster** |
-| 100 users (20KB) | 658K ops/sec | 243K ops/sec | **ata 2.7x faster** |
-| 1,000 users (205KB) | 64K ops/sec | 23.5K ops/sec | **ata 2.7x faster** |
+| 10 users (2KB) | 6.0M ops/sec | 2.4M ops/sec | **ata 2.5x faster** |
+| 100 users (20KB) | 621K ops/sec | 229K ops/sec | **ata 2.7x faster** |
+| 1,000 users (205KB) | 63K ops/sec | 22.5K ops/sec | **ata 2.8x faster** |
 
 ### Real-World Scenarios
 
@@ -97,10 +106,10 @@ Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, d
 | Scenario | ata | ajv | |
 |---|---|---|---|
 | **$dynamicRef tree** valid | 22ns | 54ns | **ata 2.4x faster** |
-| **$dynamicRef tree** invalid | 70ns | 76ns | **ata 1.1x faster** |
-| **$dynamicRef override** valid | 2.6ns | 183ns | **ata 70x faster** |
-| **$dynamicRef override** invalid | 48ns | 185ns | **ata 3.8x faster** |
-| **$anchor array** valid | 2.3ns | 3.1ns | **ata 1.4x faster** |
+| **$dynamicRef tree** invalid | 71ns | 77ns | **ata 1.1x faster** |
+| **$dynamicRef override** valid | 2.6ns | 187ns | **ata 71x faster** |
+| **$dynamicRef override** invalid | 50ns | 189ns | **ata 3.8x faster** |
+| **$anchor array** valid | 2.2ns | 3.2ns | **ata 1.4x faster** |
 
 Self-recursive named functions for $dynamicRef, compile-time cross-schema resolution, zero-wrapper hybrid path. [Benchmark code](benchmark/bench_dynamicref_vs_ajv.mjs)
 
@@ -110,7 +119,7 @@ Self-recursive named functions for $dynamicRef, compile-time cross-schema resolu
 
 ## When to use ata
 
-- **High-throughput `validate(obj)`** - 3.1x faster than ajv, 38x faster than zod
+- **High-throughput `validate(obj)`** - 5.1x faster than ajv, 47x faster than zod
 - **Complex schemas** - `patternProperties`, `dependentSchemas`, `propertyNames`, `unevaluatedProperties` all inline JS codegen
 - **Multi-schema projects** - cross-schema `$ref` with `$id` registry, `addSchema()` API
 - **Draft 7 migration** - auto-detects `$schema`, normalizes Draft 7 keywords transparently

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
@@ -973,15 +979,33 @@ function tryGenCombined(schema, access, ctx) {
 
   if (t === 'string') {
     if (schema.pattern || schema.format) return null
-    // Both bounds set: hoist _cpLen once so ASCII strings are not scanned twice.
+    // s.length is an upper bound on cpLen and at least cpLen / 2 (worst case
+    // all-surrogate). Use s.length fast paths and only call _cpLen in the
+    // uncertain band; ASCII strings (>99% of real data) skip _cpLen entirely.
     if (schema.minLength !== undefined && schema.maxLength !== undefined) {
+      const M = schema.minLength
+      const X = schema.maxLength
       const v2 = isIdent ? access : '_v'
       const prelude = isIdent ? '' : `const _v=${access};`
-      return `{${prelude}if(typeof ${v2}!=='string')return false;const _lv=_cpLen(${v2});if(_lv<${schema.minLength}||_lv>${schema.maxLength})return false}`
+      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) conds.push(`_cpLen(_v)<${schema.minLength}`)
-    if (schema.maxLength !== undefined) conds.push(`_cpLen(_v)>${schema.maxLength}`)
+    if (schema.minLength !== undefined && schema.minLength > 0) {
+      const M = schema.minLength
+      conds.push(`_v.length<${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
+      // 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)
   }
@@ -1235,20 +1259,38 @@ function genCode(schema, v, lines, ctx, knownType) {
   if (schema.exclusiveMaximum !== undefined) lines.push(isNum ? `if(${v}>=${schema.exclusiveMaximum})return false` : `if(typeof ${v}==='number'&&${v}>=${schema.exclusiveMaximum})return false`)
   if (schema.multipleOf !== undefined) lines.push(isNum ? `if(${v}%${schema.multipleOf}!==0)return false` : `if(typeof ${v}==='number'&&${v}%${schema.multipleOf}!==0)return false`)
 
-  // string — skip type guard if known string. When both bounds are set, call
-  // _cpLen once and compare the cached result so ASCII strings do not get
-  // scanned twice.
+  // string length — skip type guard if known string.
+  // s.length (UTF-16 code units) is an upper bound on cpLen, and at least cpLen
+  // (worst case all surrogate pairs gives s.length = 2 * cpLen). So:
+  //   length < M           → certain fail minLength
+  //   length > 2*X         → certain fail maxLength
+  //   2*M <= length <= X   → certain pass both
+  // Only call _cpLen in the uncertain band. ASCII strings (>99% of real data)
+  // never enter the band.
   if (schema.minLength !== undefined && schema.maxLength !== undefined) {
+    const M = schema.minLength
+    const X = schema.maxLength
     const li = ctx.varCounter++
     const lv = `_l${li}`
-    if (isStr) {
-      lines.push(`{const ${lv}=_cpLen(${v});if(${lv}<${schema.minLength}||${lv}>${schema.maxLength})return false}`)
-    } else {
-      lines.push(`if(typeof ${v}==='string'){const ${lv}=_cpLen(${v});if(${lv}<${schema.minLength}||${lv}>${schema.maxLength})return false}`)
-    }
+    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) lines.push(isStr ? `if(_cpLen(${v})<${schema.minLength})return false` : `if(typeof ${v}==='string'&&_cpLen(${v})<${schema.minLength})return false`)
-    if (schema.maxLength !== undefined) lines.push(isStr ? `if(_cpLen(${v})>${schema.maxLength})return false` : `if(typeof ${v}==='string'&&_cpLen(${v})>${schema.maxLength})return false`)
+    if (schema.minLength !== undefined && schema.minLength > 0) {
+      const M = schema.minLength
+      // 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
+      // 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}}`)
+    }
   }
 
   // array size — skip guard if known array
@@ -1579,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
@@ -2199,9 +2263,20 @@ function compilePatternInline(pattern, varName) {
   // Match: ^[chars]{exact}$ — e.g., ^[0-9]{5}$
   let m = pattern.match(/^\^(\[[\w\-]+\])\{(\d+)\}\$$/)
   if (m) {
+    const len = parseInt(m[2])
+    // For small fixed-length patterns, fully unroll: avoids the per-call closure
+    // allocation of the IIFE form. Cap at 16 chars to keep emitted code small.
+    if (len <= 16) {
+      const checks = []
+      for (let i = 0; i < len; i++) {
+        const ck = charClassToCheck(m[1], `${varName}.charCodeAt(${i})`)
+        if (!ck) return null
+        checks.push(ck)
+      }
+      return `${varName}.length===${len}&&${checks.join('&&')}`
+    }
     const rangeCheck = charClassToCheck(m[1], `${varName}.charCodeAt(_pi)`)
     if (!rangeCheck) return null
-    const len = parseInt(m[2])
     return `${varName}.length===${len}&&(()=>{for(let _pi=0;_pi<${len};_pi++){if(!(${rangeCheck}))return false}return true})()`
   }
   // Match: ^[chars]+$ — e.g., ^[a-z]+$
@@ -2539,14 +2614,21 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     lines.push(`{const _r${ci}=typeof ${v}==='number'?${v}%${m}:NaN;if(typeof ${v}==='number'&&Math.abs(_r${ci})>1e-8&&Math.abs(_r${ci}-${m})>1e-8){${fail('multipleOf', 'multipleOf', `{multipleOf:${m}}`, `'must be multiple of ${m}'`)}}}`)
   }
 
-  // string
+  // string length — same s.length fast paths as the boolean codegen above.
+  // length < M → certain fail; length > 2*X → certain fail; sweet spot
+  // 2*M <= length <= X passes without scanning. Only call _cpLen in the
+  // uncertain band (caches it so it isn't called twice when both bounds are set).
   if (schema.minLength !== undefined) {
-    const c = isStr ? `_cpLen(${v})<${schema.minLength}` : `typeof ${v}==='string'&&_cpLen(${v})<${schema.minLength}`
-    lines.push(`if(${c}){${fail('minLength', 'minLength', `{limit:${schema.minLength}}`, `'must NOT have fewer than ${schema.minLength} characters'`)}}`)
+    const M = schema.minLength
+    const inner = `${v}.length<${M}||(${v}.length<${M * 2}&&_cpLen(${v})<${M})`
+    const c = isStr ? inner : `typeof ${v}==='string'&&(${inner})`
+    lines.push(`if(${c}){${fail('minLength', 'minLength', `{limit:${M}}`, `'must NOT have fewer than ${M} characters'`)}}`)
   }
   if (schema.maxLength !== undefined) {
-    const c = isStr ? `_cpLen(${v})>${schema.maxLength}` : `typeof ${v}==='string'&&_cpLen(${v})>${schema.maxLength}`
-    lines.push(`if(${c}){${fail('maxLength', 'maxLength', `{limit:${schema.maxLength}}`, `'must NOT have more than ${schema.maxLength} characters'`)}}`)
+    const X = schema.maxLength
+    const inner = `${v}.length>${X * 2}||(${v}.length>${X}&&_cpLen(${v})>${X})`
+    const c = isStr ? inner : `typeof ${v}==='string'&&(${inner})`
+    lines.push(`if(${c}){${fail('maxLength', 'maxLength', `{limit:${X}}`, `'must NOT have more than ${X} characters'`)}}`)
   }
   if (schema.pattern) {
     const inlineCheck = compilePatternInline(schema.pattern, v)
@@ -3081,9 +3163,19 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     lines.push(`{const _r${ci}=typeof ${v}==='number'?${v}%${m}:NaN;if(typeof ${v}==='number'&&Math.abs(_r${ci})>1e-8&&Math.abs(_r${ci}-${m})>1e-8){${fail('multipleOf', 'multipleOf', `{multipleOf:${m}}`, `'must be multiple of ${m}'`)}}}`)
   }
 
-  // string — skip guard if known
-  if (schema.minLength !== undefined) { const c = isStr ? `_cpLen(${v})<${schema.minLength}` : `typeof ${v}==='string'&&_cpLen(${v})<${schema.minLength}`; lines.push(`if(${c}){${fail('minLength', 'minLength', `{limit:${schema.minLength}}`, `'must NOT have fewer than ${schema.minLength} characters'`)}}`) }
-  if (schema.maxLength !== undefined) { const c = isStr ? `_cpLen(${v})>${schema.maxLength}` : `typeof ${v}==='string'&&_cpLen(${v})>${schema.maxLength}`; lines.push(`if(${c}){${fail('maxLength', 'maxLength', `{limit:${schema.maxLength}}`, `'must NOT have more than ${schema.maxLength} characters'`)}}`) }
+  // string length — s.length fast paths, _cpLen only in the uncertain band.
+  if (schema.minLength !== undefined) {
+    const M = schema.minLength
+    const inner = `${v}.length<${M}||(${v}.length<${M * 2}&&_cpLen(${v})<${M})`
+    const c = isStr ? inner : `typeof ${v}==='string'&&(${inner})`
+    lines.push(`if(${c}){${fail('minLength', 'minLength', `{limit:${M}}`, `'must NOT have fewer than ${M} characters'`)}}`)
+  }
+  if (schema.maxLength !== undefined) {
+    const X = schema.maxLength
+    const inner = `${v}.length>${X * 2}||(${v}.length>${X}&&_cpLen(${v})>${X})`
+    const c = isStr ? inner : `typeof ${v}==='string'&&(${inner})`
+    lines.push(`if(${c}){${fail('maxLength', 'maxLength', `{limit:${X}}`, `'must NOT have more than ${X} characters'`)}}`)
+  }
   if (schema.pattern) {
     const inlineCheck = compilePatternInline(schema.pattern, v)
     if (inlineCheck) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ata-validator",
-  "version": "0.12.0",
-  "description": "Ultra-fast JSON Schema validator. 4.7x faster validation, 1,800x faster compilation. Works without native addon. Cross-schema $ref, Draft 2020-12 + Draft 7, V8-optimized JS codegen, simdjson, RE2, multi-core. Standard Schema V1 compatible.",
+  "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",
   "types": "index.d.ts",

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;
   }