ata-validator 0.4.1 → 0.4.3

package/index.js

@@ -1,5 +1,5 @@
 const native = require("node-gyp-build")(__dirname);
-const { compileToJS, compileToJSCodegen } = require("./lib/js-compiler");
+const { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined } = require("./lib/js-compiler");
 
 // Extract default values from a schema tree. Returns a function that applies
 // defaults to an object in-place (mutates), or null if no defaults exist.
@@ -49,6 +49,131 @@ function collectDefaults(schema, actions, path) {
   }
 }
 
+// Build a function that coerces property values to match schema types in-place.
+// Handles string→number, string→integer, string→boolean, number→string, boolean→string.
+function buildCoercer(schema) {
+  if (typeof schema !== 'object' || schema === null) return null;
+  const actions = [];
+  collectCoercions(schema, actions);
+  if (actions.length === 0) return null;
+  return (data) => {
+    for (let i = 0; i < actions.length; i++) actions[i](data);
+  };
+}
+
+function collectCoercions(schema, actions, path) {
+  if (typeof schema !== 'object' || schema === null) return;
+  const props = schema.properties;
+  if (!props) return;
+  for (const [key, prop] of Object.entries(props)) {
+    if (!prop || typeof prop !== 'object' || !prop.type) continue;
+    const targetType = Array.isArray(prop.type) ? null : prop.type;
+    if (!targetType) continue;
+
+    const coerce = buildSingleCoercion(targetType);
+    if (!coerce) continue;
+
+    if (!path) {
+      actions.push((data) => {
+        if (typeof data === 'object' && data !== null && key in data) {
+          const coerced = coerce(data[key]);
+          if (coerced !== undefined) data[key] = coerced;
+        }
+      });
+    } else {
+      const parentPath = path;
+      actions.push((data) => {
+        let target = data;
+        for (let j = 0; j < parentPath.length; j++) {
+          if (typeof target !== 'object' || target === null) return;
+          target = target[parentPath[j]];
+        }
+        if (typeof target === 'object' && target !== null && key in target) {
+          const coerced = coerce(target[key]);
+          if (coerced !== undefined) target[key] = coerced;
+        }
+      });
+    }
+
+    // Recurse into nested object properties
+    if (prop.properties) {
+      collectCoercions(prop, actions, (path || []).concat(key));
+    }
+  }
+}
+
+function buildSingleCoercion(targetType) {
+  switch (targetType) {
+    case 'number': return (v) => {
+      if (typeof v === 'string') { const n = Number(v); if (v !== '' && !isNaN(n)) return n; }
+      if (typeof v === 'boolean') return v ? 1 : 0;
+    };
+    case 'integer': return (v) => {
+      if (typeof v === 'string') { const n = Number(v); if (v !== '' && Number.isInteger(n)) return n; }
+      if (typeof v === 'boolean') return v ? 1 : 0;
+    };
+    case 'string': return (v) => {
+      if (typeof v === 'number' || typeof v === 'boolean') return String(v);
+    };
+    case 'boolean': return (v) => {
+      if (v === 'true' || v === '1') return true;
+      if (v === 'false' || v === '0') return false;
+    };
+    default: return null;
+  }
+}
+
+// Build a function that removes properties not defined in schema.properties.
+// Walks nested objects recursively.
+function buildRemover(schema) {
+  if (typeof schema !== 'object' || schema === null) return null;
+  const actions = [];
+  collectRemovals(schema, actions);
+  if (actions.length === 0) return null;
+  return (data) => {
+    for (let i = 0; i < actions.length; i++) actions[i](data);
+  };
+}
+
+function collectRemovals(schema, actions, path) {
+  if (typeof schema !== 'object' || schema === null || !schema.properties) return;
+
+  // If this level has additionalProperties: false, add a removal action
+  if (schema.additionalProperties === false) {
+    const allowed = new Set(Object.keys(schema.properties));
+    if (!path) {
+      actions.push((data) => {
+        if (typeof data !== 'object' || data === null || Array.isArray(data)) return;
+        const keys = Object.keys(data);
+        for (let i = 0; i < keys.length; i++) {
+          if (!allowed.has(keys[i])) delete data[keys[i]];
+        }
+      });
+    } else {
+      const parentPath = path;
+      actions.push((data) => {
+        let target = data;
+        for (let j = 0; j < parentPath.length; j++) {
+          if (typeof target !== 'object' || target === null) return;
+          target = target[parentPath[j]];
+        }
+        if (typeof target !== 'object' || target === null || Array.isArray(target)) return;
+        const keys = Object.keys(target);
+        for (let i = 0; i < keys.length; i++) {
+          if (!allowed.has(keys[i])) delete target[keys[i]];
+        }
+      });
+    }
+  }
+
+  // Always recurse into nested properties (they may have their own additionalProperties: false)
+  for (const [key, prop] of Object.entries(schema.properties)) {
+    if (prop && typeof prop === 'object' && prop.properties) {
+      collectRemovals(prop, actions, (path || []).concat(key));
+    }
+  }
+}
+
 const SIMDJSON_PADDING = 64;
 const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
 
@@ -75,7 +200,8 @@ function createPaddedBuffer(jsonStr) {
 }
 
 class Validator {
-  constructor(schema) {
+  constructor(schema, opts) {
+    const options = opts || {};
     const schemaStr =
       typeof schema === "string" ? schema : JSON.stringify(schema);
     const compiled = new native.CompiledSchema(schemaStr);
@@ -88,12 +214,29 @@ class Validator {
     const jsFn = process.env.ATA_FORCE_NAPI
       ? null
       : (compileToJSCodegen(schemaObj) || compileToJS(schemaObj));
+    // Combined validator: single pass, validates + collects errors, all optimized
+    const jsCombinedFn = process.env.ATA_FORCE_NAPI
+      ? null
+      : compileToJSCombined(schemaObj, VALID_RESULT);
+    // Fallback error-collecting codegen (less optimized, for schemas combined can't handle)
+    const jsErrFn = (!jsCombinedFn && !process.env.ATA_FORCE_NAPI)
+      ? compileToJSCodegenWithErrors(schemaObj)
+      : null;
     this._jsFn = jsFn;
 
-    // Default value applier — applies schema defaults to objects in-place
+    // Data mutators — applied in-place before validation
     const applyDefaults = buildDefaultsApplier(schemaObj);
+    const applyCoerce = options.coerceTypes ? buildCoercer(schemaObj) : null;
+    const applyRemove = options.removeAdditional ? buildRemover(schemaObj) : null;
     this._applyDefaults = applyDefaults;
 
+    // Combine all mutators into a single pre-validation step
+    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); };
+    this._preprocess = preprocess;
+
     // Closure-capture: avoid `this` property lookup on every call.
     // V8 keeps closure vars in registers — no hidden class traversal.
     const fastSlot = this._fastSlot;
@@ -107,34 +250,31 @@ class Validator {
     const useSimdjsonForLarge = !hasArrayTraversal;
 
     if (jsFn) {
-      this.validate = applyDefaults
-        ? (data) => { applyDefaults(data); return jsFn(data) ? VALID_RESULT : compiled.validate(data); }
-        : (data) => jsFn(data) ? VALID_RESULT : compiled.validate(data);
+      // Error handler: combined (optimized) → jsErrFn → NAPI fallback
+      const errFn = jsCombinedFn
+        ? (d) => { try { return jsCombinedFn(d); } catch { return compiled.validate(d); } }
+        : jsErrFn
+          ? (d) => { try { return jsErrFn(d, true); } catch { return compiled.validate(d); } }
+          : (d) => compiled.validate(d);
+      this.validate = preprocess
+        ? (data) => { preprocess(data); return jsFn(data) ? VALID_RESULT : errFn(data); }
+        : (data) => jsFn(data) ? VALID_RESULT : errFn(data);
       this.isValidObject = jsFn;
+      const jsonValidateFn = (obj) => jsFn(obj) ? VALID_RESULT : errFn(obj);
       this.validateJSON = useSimdjsonForLarge
         ? (jsonStr) => {
-            // Selective schema: large docs use simdjson (skips irrelevant data)
             if (jsonStr.length >= SIMDJSON_THRESHOLD) {
               const buf = Buffer.from(jsonStr);
               if (native.rawFastValidate(fastSlot, buf)) return VALID_RESULT;
               return compiled.validateJSON(jsonStr);
             }
-            try {
-              const obj = JSON.parse(jsonStr);
-              if (jsFn(obj)) return VALID_RESULT;
-            } catch (e) {
-              if (!(e instanceof SyntaxError)) throw e;
-            }
+            try { return jsonValidateFn(JSON.parse(jsonStr)); }
+            catch (e) { if (!(e instanceof SyntaxError)) throw e; }
             return compiled.validateJSON(jsonStr);
           }
         : (jsonStr) => {
-            // Non-selective schema: JSON.parse + jsFn always wins
-            try {
-              const obj = JSON.parse(jsonStr);
-              if (jsFn(obj)) return VALID_RESULT;
-            } catch (e) {
-              if (!(e instanceof SyntaxError)) throw e;
-            }
+            try { return jsonValidateFn(JSON.parse(jsonStr)); }
+            catch (e) { if (!(e instanceof SyntaxError)) throw e; }
             return compiled.validateJSON(jsonStr);
           };
       this.isValidJSON = useSimdjsonForLarge
@@ -177,7 +317,7 @@ class Validator {
 
   // Fallback methods — only used when JS codegen is unavailable
   validate(data) {
-    if (this._applyDefaults) this._applyDefaults(data);
+    if (this._preprocess) this._preprocess(data);
     return this._compiled.validate(data);
   }
 

package/lib/js-compiler.js

@@ -437,18 +437,30 @@ function codegenSafe(schema) {
     }
   }
 
-  // Required keys that collide with Object.prototype
+  // Keys that collide with Object.prototype
   if (schema.required) {
     for (const k of schema.required) {
       if (UNSAFE_KEYS.has(k)) return false
     }
   }
+  if (schema.properties) {
+    for (const k of Object.keys(schema.properties)) {
+      if (UNSAFE_KEYS.has(k)) return false
+      if (k === '$ref') return false // property named "$ref" — confusing
+    }
+  }
 
   // Unicode property escapes in pattern need 'u' flag — codegen uses RegExp without it
   if (schema.pattern && /\\[pP]\{/.test(schema.pattern)) return false
 
-  // $ref — bail entirely from codegen; ref resolution has too many edge cases
-  if (schema.$ref) return false
+  // $ref — allow only simple local refs (#/$defs/Name), no $id, no sibling keywords
+  if (schema.$ref) {
+    if (!/^#\/(?:\$defs|definitions)\/[^/]+$/.test(schema.$ref)) return false
+    // Bail if $ref has sibling keywords (complex interaction)
+    const siblings = Object.keys(schema).filter(k => k !== '$ref' && k !== '$defs' && k !== 'definitions' && k !== '$schema')
+    if (siblings.length > 0) return false
+  }
+  if (schema.$id) return false
 
   // additionalProperties as schema — bail entirely, too many edge cases with allOf interaction
   if (typeof schema.additionalProperties === 'object') return false
@@ -457,6 +469,19 @@ function codegenSafe(schema) {
   // propertyNames: false — codegen doesn't handle this
   if (schema.propertyNames === false) return false
 
+  // Check $defs: targets must be safe, names must be simple, no nested $ref chains
+  const defs = schema.$defs || schema.definitions
+  if (defs) {
+    for (const [name, def] of Object.entries(defs)) {
+      if (/[~/"']/.test(name)) return false // special chars in def name
+      if (typeof def === 'boolean') return false
+      if (typeof def === 'object' && def !== null) {
+        if (def.$ref) return false // nested ref chain — bail
+        if (!codegenSafe(def)) return false
+      }
+    }
+  }
+
   // Recurse into sub-schemas — bail on boolean schemas in any position
   const subs = [
     schema.items, schema.contains, schema.not,
@@ -498,8 +523,10 @@ function compileToJSCodegen(schema) {
   genCode(schema, 'd', lines, ctx)
   if (lines.length === 0) return () => true
 
-  const body = (ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : '') +
-               lines.join('\n  ') + '\n  return true'
+  const helperStr = ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : ''
+  const checkStr = lines.join('\n  ')
+  const body = helperStr + checkStr + '\n  return true'
+
   try {
     return new Function('d', body)
   } catch {
@@ -648,16 +675,19 @@ function genCode(schema, v, lines, ctx, knownType) {
     if (fc) lines.push(fc(v, isStr))
   }
 
-  // uniqueItems — fast path for primitive arrays (no JSON.stringify)
+  // uniqueItems — tiered strategy based on expected array size
   if (schema.uniqueItems) {
     const si = ctx.varCounter++
-    // If items schema is a primitive type, skip JSON.stringify entirely
     const itemType = schema.items && typeof schema.items === 'object' && schema.items.type
     const isPrimItems = itemType === 'string' || itemType === 'number' || itemType === 'integer'
-    // For objects: use sorted-key JSON.stringify to handle key order correctly per spec
-    const inner = isPrimItems
-      ? `const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){if(_s${si}.has(${v}[_i]))return false;_s${si}.add(${v}[_i])}`
-      : `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);if(_s${si}.has(_k))return false;_s${si}.add(_k)}`
+    const maxItems = schema.maxItems
+    // Small primitive arrays (maxItems <= 16): nested loop is 6x faster than Set
+    // No allocation, no hash computation — just direct === comparison
+    const inner = isPrimItems && maxItems && maxItems <= 16
+      ? `for(let _i=1;_i<${v}.length;_i++){for(let _k=0;_k<_i;_k++){if(${v}[_i]===${v}[_k])return false}}`
+      : isPrimItems
+        ? `const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){if(_s${si}.has(${v}[_i]))return false;_s${si}.add(${v}[_i])}`
+        : `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);if(_s${si}.has(_k))return false;_s${si}.add(_k)}`
     lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
   }
 
@@ -842,4 +872,620 @@ const FORMAT_CODEGEN = {
 // Safe key escaping: use JSON.stringify to handle all special chars (newlines, null bytes, etc.)
 function esc(s) { return JSON.stringify(s).slice(1, -1) }
 
-module.exports = { compileToJS, compileToJSCodegen }
+// --- Error-collecting codegen: same checks, but pushes errors instead of returning false ---
+// Returns a function: (data, allErrors) => { valid, errors }
+// Valid path is still fast — only error path does extra work.
+function compileToJSCodegenWithErrors(schema) {
+  if (typeof schema === 'boolean') {
+    return schema
+      ? () => ({ valid: true, errors: [] })
+      : () => ({ valid: false, errors: [{ code: 'type_mismatch', path: '', message: 'schema is false' }] })
+  }
+  if (typeof schema !== 'object' || schema === null) return null
+  if (!codegenSafe(schema)) return null
+  if (schema.patternProperties || schema.dependentSchemas || schema.propertyNames) return null
+
+  const ctx = { varCounter: 0, helperCode: [], rootDefs: schema.$defs || schema.definitions || null, refStack: new Set() }
+  const lines = []
+  genCodeE(schema, 'd', '', lines, ctx)
+  if (lines.length === 0) return (d) => ({ valid: true, errors: [] })
+
+  const body = `const _e=[];\n  ` +
+    (ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : '') +
+    lines.join('\n  ') +
+    `\n  return{valid:_e.length===0,errors:_e}`
+  try {
+    return new Function('d', '_all', body)
+  } catch {
+    return null
+  }
+}
+
+// Error-collecting code generator.
+// Instead of `return false`, pushes to `_e` array and optionally early-returns.
+// `_all` parameter: if falsy, return after first error.
+function genCodeE(schema, v, pathExpr, lines, ctx) {
+  if (typeof schema !== 'object' || schema === null) return
+
+  // $ref — resolve local refs
+  if (schema.$ref && ctx.rootDefs) {
+    const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
+    if (m && ctx.rootDefs[m[1]]) {
+      genCodeE(ctx.rootDefs[m[1]], v, pathExpr, lines, ctx)
+    }
+  }
+
+  const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null
+  if (types) {
+    const conds = types.map(t => {
+      switch (t) {
+        case 'object': return `(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+        case 'array': return `Array.isArray(${v})`
+        case 'string': return `typeof ${v}==='string'`
+        case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
+        case 'integer': return `Number.isInteger(${v})`
+        case 'boolean': return `typeof ${v}==='boolean'`
+        case 'null': return `${v}===null`
+        default: return 'true'
+      }
+    })
+    const expected = types.join(', ')
+    lines.push(`if(!(${conds.join('||')})){_e.push({code:'type_mismatch',path:${pathExpr||'""'},message:'expected ${expected}'});if(!_all)return{valid:false,errors:_e}}`)
+  }
+
+  // In error mode, never assume type — always guard (data may have failed type check but allErrors continues)
+  const isObj = false
+  const isArr = false
+  const isStr = false
+  const isNum = false
+
+  const fail = (code, msg) => `_e.push({code:'${code}',path:${pathExpr||'""'},message:${msg}});if(!_all)return{valid:false,errors:_e}`
+
+  // enum
+  if (schema.enum) {
+    const vals = schema.enum
+    const primitives = vals.filter(v => v === null || typeof v !== 'object')
+    const objects = vals.filter(v => v !== null && typeof v === 'object')
+    const primChecks = primitives.map(p => `${v}===${JSON.stringify(p)}`).join('||')
+    const objChecks = objects.map(o => `JSON.stringify(${v})===${JSON.stringify(JSON.stringify(o))}`).join('||')
+    const allChecks = [primChecks, objChecks].filter(Boolean).join('||')
+    lines.push(`if(!(${allChecks || 'false'})){${fail('enum_mismatch', "'value not in enum'")}}`)
+  }
+
+  // const — use canonical (sorted-key) comparison for objects
+  if (schema.const !== undefined) {
+    const cv = schema.const
+    if (cv === null || typeof cv !== 'object') {
+      lines.push(`if(${v}!==${JSON.stringify(cv)}){${fail('const_mismatch', "'value does not match const'")}}`)
+    } else {
+      // Pre-compute canonical form of const value
+      const ci = ctx.varCounter++
+      const canonFn = `_cnE${ci}`
+      ctx.helperCode.push(`const ${canonFn}=function(x){if(x===null||typeof x!=='object')return JSON.stringify(x);if(Array.isArray(x))return'['+x.map(${canonFn}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+${canonFn}(x[k])}).join(',')+'}'};`)
+      const expected = canonFn + '(' + JSON.stringify(cv) + ')'
+      lines.push(`if(${canonFn}(${v})!==${expected}){${fail('const_mismatch', "'value does not match const'")}}`)
+    }
+  }
+
+  // required — no destructuring in error mode (data might not be an object)
+  const requiredSet = new Set(schema.required || [])
+  const hoisted = {}
+  if (schema.required) {
+    for (const key of schema.required) {
+      const p = pathExpr ? `${pathExpr}+'/${esc(key)}'` : `'/${esc(key)}'`
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){_e.push({code:'required_missing',path:${p},message:'missing required: ${esc(key)}'});if(!_all)return{valid:false,errors:_e}}`)
+    }
+  }
+
+  // numeric
+  if (schema.minimum !== undefined) {
+    const c = isNum ? `${v}<${schema.minimum}` : `typeof ${v}==='number'&&${v}<${schema.minimum}`
+    lines.push(`if(${c}){${fail('minimum_violation', `'minimum ${schema.minimum}'`)}}`)
+  }
+  if (schema.maximum !== undefined) {
+    const c = isNum ? `${v}>${schema.maximum}` : `typeof ${v}==='number'&&${v}>${schema.maximum}`
+    lines.push(`if(${c}){${fail('maximum_violation', `'maximum ${schema.maximum}'`)}}`)
+  }
+  if (schema.exclusiveMinimum !== undefined) {
+    const c = isNum ? `${v}<=${schema.exclusiveMinimum}` : `typeof ${v}==='number'&&${v}<=${schema.exclusiveMinimum}`
+    lines.push(`if(${c}){${fail('exclusive_minimum_violation', `'exclusiveMinimum ${schema.exclusiveMinimum}'`)}}`)
+  }
+  if (schema.exclusiveMaximum !== undefined) {
+    const c = isNum ? `${v}>=${schema.exclusiveMaximum}` : `typeof ${v}==='number'&&${v}>=${schema.exclusiveMaximum}`
+    lines.push(`if(${c}){${fail('exclusive_maximum_violation', `'exclusiveMaximum ${schema.exclusiveMaximum}'`)}}`)
+  }
+  if (schema.multipleOf !== undefined) {
+    const m = schema.multipleOf
+    const ci = ctx.varCounter++
+    // Use tolerance-based check for floating point (matches C++ behavior)
+    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('multiple_of_violation', `'multipleOf ${m}'`)}}}`)
+  }
+
+  // string
+  if (schema.minLength !== undefined) {
+    const c = isStr ? `${v}.length<${schema.minLength}` : `typeof ${v}==='string'&&${v}.length<${schema.minLength}`
+    lines.push(`if(${c}){${fail('min_length_violation', `'minLength ${schema.minLength}'`)}}`)
+  }
+  if (schema.maxLength !== undefined) {
+    const c = isStr ? `${v}.length>${schema.maxLength}` : `typeof ${v}==='string'&&${v}.length>${schema.maxLength}`
+    lines.push(`if(${c}){${fail('max_length_violation', `'maxLength ${schema.maxLength}'`)}}`)
+  }
+  if (schema.pattern) {
+    const ri = ctx.varCounter++
+    ctx.helperCode.push(`const _re${ri}=new RegExp(${JSON.stringify(schema.pattern)})`)
+    const c = isStr ? `!_re${ri}.test(${v})` : `typeof ${v}==='string'&&!_re${ri}.test(${v})`
+    lines.push(`if(${c}){${fail('pattern_mismatch', `'pattern mismatch'`)}}`)
+  }
+  if (schema.format) {
+    const fc = FORMAT_CODEGEN[schema.format]
+    // Format errors use the boolean codegen — just wrap with error push
+    if (fc) {
+      const ri = ctx.varCounter++
+      const boolLines = []
+      boolLines.push(fc(v, isStr))
+      // Replace `return false` with error push in the format check
+      const fmtCode = boolLines.join(';').replace(/return false/g,
+        `{_e.push({code:'format_mismatch',path:${pathExpr||'""'},message:'format ${esc(schema.format)}'});if(!_all)return{valid:false,errors:_e}}`)
+      lines.push(fmtCode)
+    }
+  }
+
+  // array size
+  if (schema.minItems !== undefined) {
+    const c = isArr ? `${v}.length<${schema.minItems}` : `Array.isArray(${v})&&${v}.length<${schema.minItems}`
+    lines.push(`if(${c}){${fail('min_items_violation', `'minItems ${schema.minItems}'`)}}`)
+  }
+  if (schema.maxItems !== undefined) {
+    const c = isArr ? `${v}.length>${schema.maxItems}` : `Array.isArray(${v})&&${v}.length>${schema.maxItems}`
+    lines.push(`if(${c}){${fail('max_items_violation', `'maxItems ${schema.maxItems}'`)}}`)
+  }
+
+  // uniqueItems
+  if (schema.uniqueItems) {
+    const si = ctx.varCounter++
+    const itemType = schema.items && typeof schema.items === 'object' && schema.items.type
+    const isPrim = itemType === 'string' || itemType === 'number' || itemType === 'integer'
+    const inner = isPrim
+      ? `const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){if(_s${si}.has(${v}[_i])){${fail('unique_items_violation', "'duplicate items'")};break};_s${si}.add(${v}[_i])}`
+      : `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);if(_s${si}.has(_k)){${fail('unique_items_violation', "'duplicate items'")};break};_s${si}.add(_k)}`
+    lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
+  }
+
+  // object size
+  if (schema.minProperties !== undefined) {
+    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&Object.keys(${v}).length<${schema.minProperties}){${fail('min_properties_violation', `'minProperties ${schema.minProperties}'`)}}`)
+  }
+  if (schema.maxProperties !== undefined) {
+    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&Object.keys(${v}).length>${schema.maxProperties}){${fail('max_properties_violation', `'maxProperties ${schema.maxProperties}'`)}}`)
+  }
+
+  // additionalProperties: false
+  if (schema.additionalProperties === false && schema.properties) {
+    const allowed = Object.keys(schema.properties).map(k => `${JSON.stringify(k)}`).join(',')
+    const ci = ctx.varCounter++
+    const inner = `const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++){if(!_a${ci}.has(_k${ci}[_i])){_e.push({code:'additional_property',path:${pathExpr||'""'},message:'additional property: '+_k${ci}[_i]});if(!_all)return{valid:false,errors:_e}}}`
+    lines.push(isObj ? `{${inner}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+  }
+
+  // dependentRequired
+  if (schema.dependentRequired) {
+    for (const [key, deps] of Object.entries(schema.dependentRequired)) {
+      for (const dep of deps) {
+        const p = pathExpr ? `${pathExpr}+'/${esc(dep)}'` : `'/${esc(dep)}'`
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){_e.push({code:'required_missing',path:${p},message:'${esc(key)} requires ${esc(dep)}'});if(!_all)return{valid:false,errors:_e}}`)
+      }
+    }
+  }
+
+  // properties — always guard (error mode, data may not be an object or may be array)
+  if (schema.properties) {
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      const childPath = pathExpr ? `${pathExpr}+'/${esc(key)}'` : `'/${esc(key)}'`
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
+      genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx)
+      lines.push(`}`)
+    }
+  }
+
+  // items — starts after prefixItems (Draft 2020-12 semantics)
+  if (schema.items) {
+    const startIdx = schema.prefixItems ? schema.prefixItems.length : 0
+    const idx = `_j${ctx.varCounter}`
+    const elem = `_ei${ctx.varCounter}`
+    ctx.varCounter++
+    const childPath = pathExpr ? `${pathExpr}+'/'+${idx}` : `'/'+${idx}`
+    lines.push(`if(Array.isArray(${v})){for(let ${idx}=${startIdx};${idx}<${v}.length;${idx}++){const ${elem}=${v}[${idx}]`)
+    genCodeE(schema.items, elem, childPath, lines, ctx)
+    lines.push(`}}`)
+  }
+
+  // prefixItems
+  if (schema.prefixItems) {
+    for (let i = 0; i < schema.prefixItems.length; i++) {
+      const childPath = pathExpr ? `${pathExpr}+'/${i}'` : `'/${i}'`
+      lines.push(`if(Array.isArray(${v})&&${v}.length>${i}){`)
+      genCodeE(schema.prefixItems[i], `${v}[${i}]`, childPath, lines, ctx)
+      lines.push(`}`)
+    }
+  }
+
+  // contains
+  if (schema.contains) {
+    const ci = ctx.varCounter++
+    const subLines = []
+    genCode(schema.contains, `_cv`, subLines, ctx)
+    const fnBody = subLines.length === 0 ? `return true` : `${subLines.join(';')};return true`
+    const minC = schema.minContains !== undefined ? schema.minContains : 1
+    const maxC = schema.maxContains
+    lines.push(`if(Array.isArray(${v})){const _cf${ci}=function(_cv){${fnBody}};let _cc${ci}=0;for(let _ci${ci}=0;_ci${ci}<${v}.length;_ci${ci}++){if(_cf${ci}(${v}[_ci${ci}]))_cc${ci}++}`)
+    lines.push(`if(_cc${ci}<${minC}){${fail('contains_violation', `'contains: need at least ${minC} match(es)'`)}}`)
+    if (maxC !== undefined) {
+      lines.push(`if(_cc${ci}>${maxC}){${fail('contains_violation', `'contains: at most ${maxC} match(es)'`)}}`)
+    }
+    lines.push(`}`)
+  }
+
+  // allOf
+  if (schema.allOf) {
+    for (const sub of schema.allOf) {
+      genCodeE(sub, v, pathExpr, lines, ctx)
+    }
+  }
+
+  // anyOf
+  if (schema.anyOf) {
+    const fi = ctx.varCounter++
+    const fns = schema.anyOf.map((sub, i) => {
+      const subLines = []
+      genCode(sub, '_av', subLines, ctx)
+      return subLines.length === 0 ? `function(_av){return true}` : `function(_av){${subLines.join(';')};return true}`
+    })
+    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}){${fail('any_of_failed', "'no anyOf matched'")}}}`)
+  }
+
+  // oneOf
+  if (schema.oneOf) {
+    const fi = ctx.varCounter++
+    const fns = schema.oneOf.map((sub, i) => {
+      const subLines = []
+      genCode(sub, '_ov', subLines, ctx)
+      return subLines.length === 0 ? `function(_ov){return true}` : `function(_ov){${subLines.join(';')};return true}`
+    })
+    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)break}if(_oc${fi}!==1){${fail('one_of_failed', "'oneOf: expected 1 match, got '+_oc"+fi)}}}`)
+  }
+
+  // not
+  if (schema.not) {
+    const subLines = []
+    genCode(schema.not, '_nv', subLines, ctx)
+    const nfn = subLines.length === 0 ? `function(_nv){return true}` : `function(_nv){${subLines.join(';')};return true}`
+    const fi = ctx.varCounter++
+    lines.push(`{const _nf${fi}=${nfn};if(_nf${fi}(${v})){${fail('not_failed', "'should not match'")}}}`)
+  }
+
+  // if/then/else
+  if (schema.if) {
+    const ifLines = []
+    genCode(schema.if, '_iv', ifLines, ctx)
+    const fi = ctx.varCounter++
+    const ifFn = ifLines.length === 0
+      ? `function(_iv){return true}`
+      : `function(_iv){${ifLines.join(';')};return true}`
+    lines.push(`{const _if${fi}=${ifFn}`)
+    if (schema.then) {
+      lines.push(`if(_if${fi}(${v})){`)
+      genCodeE(schema.then, v, pathExpr, lines, ctx)
+      lines.push(`}`)
+    }
+    if (schema.else) {
+      lines.push(`${schema.then ? 'else' : `if(!_if${fi}(${v}))`}{`)
+      genCodeE(schema.else, v, pathExpr, lines, ctx)
+      lines.push(`}`)
+    }
+    lines.push(`}`)
+  }
+}
+
+// --- Combined validator: single pass, validates + collects errors ---
+// Returns VALID_RESULT for valid data, {valid:false, errors} for invalid.
+// Avoids double-pass (jsFn → false → errFn runs same checks again).
+// Uses type-aware optimizations: after type check passes, skip guards.
+function compileToJSCombined(schema, VALID_RESULT) {
+  if (typeof schema === 'boolean') {
+    return schema
+      ? () => VALID_RESULT
+      : () => ({ valid: false, errors: [{ code: 'type_mismatch', path: '', message: 'schema is false' }] })
+  }
+  if (typeof schema !== 'object' || schema === null) return null
+  if (!codegenSafe(schema)) return null
+  if (schema.patternProperties || schema.dependentSchemas || schema.propertyNames) return null
+
+  const ctx = { varCounter: 0, helperCode: [], closureVars: [], closureVals: [],
+                rootDefs: schema.$defs || schema.definitions || null, refStack: new Set() }
+  const lines = []
+  genCodeC(schema, 'd', '', lines, ctx)
+  if (lines.length === 0) return () => VALID_RESULT
+
+  // Use factory pattern: closure vars (regexes, etc.) created once, not per call
+  const closureParams = ctx.closureVars.join(',')
+  const inner = `const _e=[];\n  ` +
+    (ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : '') +
+    lines.join('\n  ') +
+    `\n  return _e.length===0?R:{valid:false,errors:_e}`
+
+  try {
+    const factory = new Function('R' + (closureParams ? ',' + closureParams : ''),
+      `return function(d){${inner}}`)
+    return factory(VALID_RESULT, ...ctx.closureVals)
+  } catch {
+    return null
+  }
+}
+
+// Combined code generator: type-aware like genCode, error-collecting like genCodeE.
+// After type check passes → use optimizations (destructuring, no guards).
+// If type check fails → push error, skip property checks (they'd crash).
+function genCodeC(schema, v, pathExpr, lines, ctx) {
+  if (typeof schema !== 'object' || schema === null) return
+
+  // $ref — resolve local refs
+  if (schema.$ref && ctx.rootDefs) {
+    const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
+    if (m && ctx.rootDefs[m[1]]) {
+      genCodeC(ctx.rootDefs[m[1]], v, pathExpr, lines, ctx)
+    }
+  }
+
+  const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null
+  let isObj = false, isArr = false, isStr = false, isNum = false
+
+  const fail = (code, msg) => `_e.push({code:'${code}',path:${pathExpr||'""'},message:${msg}})`
+
+  if (types) {
+    const conds = types.map(t => {
+      switch (t) {
+        case 'object': return `(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+        case 'array': return `Array.isArray(${v})`
+        case 'string': return `typeof ${v}==='string'`
+        case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
+        case 'integer': return `Number.isInteger(${v})`
+        case 'boolean': return `typeof ${v}==='boolean'`
+        case 'null': return `${v}===null`
+        default: return 'true'
+      }
+    })
+    const expected = types.join(', ')
+    // Type check: push error but continue — wrap remaining in type-success block
+    const typeOk = `_tok${ctx.varCounter++}`
+    lines.push(`const ${typeOk}=${conds.join('||')}`)
+    lines.push(`if(!${typeOk}){${fail('type_mismatch', `'expected ${expected}'`)}}`)
+    // Subsequent optimized code runs inside if(typeOk){...}
+    if (types.length === 1) {
+      isObj = types[0] === 'object'
+      isArr = types[0] === 'array'
+      isStr = types[0] === 'string'
+      isNum = types[0] === 'number' || types[0] === 'integer'
+    }
+    lines.push(`if(${typeOk}){`)
+    // We'll close this block at the end of genCodeC — mark it
+    ctx._typeBlock = true
+  }
+
+  // enum
+  if (schema.enum) {
+    const vals = schema.enum
+    const primitives = vals.filter(v => v === null || typeof v !== 'object')
+    const objects = vals.filter(v => v !== null && typeof v === 'object')
+    const primChecks = primitives.map(p => `${v}===${JSON.stringify(p)}`).join('||')
+    const objChecks = objects.map(o => `JSON.stringify(${v})===${JSON.stringify(JSON.stringify(o))}`).join('||')
+    const allChecks = [primChecks, objChecks].filter(Boolean).join('||')
+    lines.push(`if(!(${allChecks || 'false'})){${fail('enum_mismatch', "'value not in enum'")}}`)
+  }
+
+  // const
+  if (schema.const !== undefined) {
+    const cv = schema.const
+    if (cv === null || typeof cv !== 'object') {
+      lines.push(`if(${v}!==${JSON.stringify(cv)}){${fail('const_mismatch', "'const mismatch'")}}`)
+    } else {
+      const ci = ctx.varCounter++
+      const canonFn = `_cn${ci}`
+      ctx.helperCode.push(`const ${canonFn}=function(x){if(x===null||typeof x!=='object')return JSON.stringify(x);if(Array.isArray(x))return'['+x.map(${canonFn}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+${canonFn}(x[k])}).join(',')+'}'};`)
+      lines.push(`if(${canonFn}(${v})!==${canonFn}(${JSON.stringify(cv)})){${fail('const_mismatch', "'const mismatch'")}}`)
+    }
+  }
+
+  // required — use destructuring when type is object (SAFE because type check already passed)
+  const requiredSet = new Set(schema.required || [])
+  const hoisted = {}
+  if (schema.required && schema.properties && isObj) {
+    const destructKeys = []
+    for (const key of schema.required) {
+      if (schema.properties[key]) {
+        const lv = `_h${ctx.varCounter++}`
+        hoisted[key] = lv
+        destructKeys.push(`${JSON.stringify(key)}:${lv}`)
+      }
+    }
+    if (destructKeys.length > 0) lines.push(`const{${destructKeys.join(',')}}=${v}`)
+    for (const key of schema.required) {
+      const check = hoisted[key] ? `${hoisted[key]}===undefined` : `${v}[${JSON.stringify(key)}]===undefined`
+      const p = pathExpr ? `${pathExpr}+'/${esc(key)}'` : `'/${esc(key)}'`
+      lines.push(`if(${check}){${`_e.push({code:'required_missing',path:${p},message:'missing: ${esc(key)}'})`}}`)
+    }
+  } else if (schema.required) {
+    for (const key of schema.required) {
+      const p = pathExpr ? `${pathExpr}+'/${esc(key)}'` : `'/${esc(key)}'`
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){_e.push({code:'required_missing',path:${p},message:'missing: ${esc(key)}'})}`)
+    }
+  }
+
+  // numeric — skip type guard if known
+  if (schema.minimum !== undefined) { const c = isNum ? `${v}<${schema.minimum}` : `typeof ${v}==='number'&&${v}<${schema.minimum}`; lines.push(`if(${c}){${fail('minimum_violation', `'min ${schema.minimum}'`)}}`) }
+  if (schema.maximum !== undefined) { const c = isNum ? `${v}>${schema.maximum}` : `typeof ${v}==='number'&&${v}>${schema.maximum}`; lines.push(`if(${c}){${fail('maximum_violation', `'max ${schema.maximum}'`)}}`) }
+  if (schema.exclusiveMinimum !== undefined) { const c = isNum ? `${v}<=${schema.exclusiveMinimum}` : `typeof ${v}==='number'&&${v}<=${schema.exclusiveMinimum}`; lines.push(`if(${c}){${fail('exclusive_minimum_violation', `'excMin ${schema.exclusiveMinimum}'`)}}`) }
+  if (schema.exclusiveMaximum !== undefined) { const c = isNum ? `${v}>=${schema.exclusiveMaximum}` : `typeof ${v}==='number'&&${v}>=${schema.exclusiveMaximum}`; lines.push(`if(${c}){${fail('exclusive_maximum_violation', `'excMax ${schema.exclusiveMaximum}'`)}}`) }
+  if (schema.multipleOf !== undefined) {
+    const m = schema.multipleOf
+    const ci = ctx.varCounter++
+    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('multiple_of_violation', `'multipleOf ${m}'`)}}}`)
+  }
+
+  // string — skip guard if known
+  if (schema.minLength !== undefined) { const c = isStr ? `${v}.length<${schema.minLength}` : `typeof ${v}==='string'&&${v}.length<${schema.minLength}`; lines.push(`if(${c}){${fail('min_length_violation', `'minLength ${schema.minLength}'`)}}`) }
+  if (schema.maxLength !== undefined) { const c = isStr ? `${v}.length>${schema.maxLength}` : `typeof ${v}==='string'&&${v}.length>${schema.maxLength}`; lines.push(`if(${c}){${fail('max_length_violation', `'maxLength ${schema.maxLength}'`)}}`) }
+  if (schema.pattern) {
+    const ri = ctx.varCounter++
+    const reVar = `_re${ri}`
+    ctx.closureVars.push(reVar)
+    ctx.closureVals.push(new RegExp(schema.pattern))
+    const c = isStr ? `!${reVar}.test(${v})` : `typeof ${v}==='string'&&!${reVar}.test(${v})`
+    lines.push(`if(${c}){${fail('pattern_mismatch', "'pattern mismatch'")}}`)
+  }
+  if (schema.format) {
+    const fc = FORMAT_CODEGEN[schema.format]
+    if (fc) {
+      const code = fc(v, isStr).replace(/return false/g, `{${fail('format_mismatch', `'format ${esc(schema.format)}'`)}}`)
+      lines.push(code)
+    }
+  }
+
+  // array size
+  if (schema.minItems !== undefined) { const c = isArr ? `${v}.length<${schema.minItems}` : `Array.isArray(${v})&&${v}.length<${schema.minItems}`; lines.push(`if(${c}){${fail('min_items_violation', `'minItems ${schema.minItems}'`)}}`) }
+  if (schema.maxItems !== undefined) { const c = isArr ? `${v}.length>${schema.maxItems}` : `Array.isArray(${v})&&${v}.length>${schema.maxItems}`; lines.push(`if(${c}){${fail('max_items_violation', `'maxItems ${schema.maxItems}'`)}}`) }
+
+  // uniqueItems
+  if (schema.uniqueItems) {
+    const si = ctx.varCounter++
+    const itemType = schema.items && typeof schema.items === 'object' && schema.items.type
+    const isPrim = itemType === 'string' || itemType === 'number' || itemType === 'integer'
+    const inner = isPrim
+      ? `const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){if(_s${si}.has(${v}[_i])){${fail('unique_items_violation', "'duplicates'")};break};_s${si}.add(${v}[_i])}`
+      : `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);if(_s${si}.has(_k)){${fail('unique_items_violation', "'duplicates'")};break};_s${si}.add(_k)}`
+    lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
+  }
+
+  // object size
+  if (schema.minProperties !== undefined) lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&Object.keys(${v}).length<${schema.minProperties}){${fail('min_properties_violation', `'minProperties ${schema.minProperties}'`)}}`)
+  if (schema.maxProperties !== undefined) lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&Object.keys(${v}).length>${schema.maxProperties}){${fail('max_properties_violation', `'maxProperties ${schema.maxProperties}'`)}}`)
+
+  // additionalProperties
+  if (schema.additionalProperties === false && schema.properties) {
+    const allowed = Object.keys(schema.properties).map(k => JSON.stringify(k)).join(',')
+    const ci = ctx.varCounter++
+    lines.push(isObj
+      ? `{const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++)if(!_a${ci}.has(_k${ci}[_i])){${fail('additional_property', `'extra: '+_k${ci}[_i]`)}}}`
+      : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++)if(!_a${ci}.has(_k${ci}[_i])){${fail('additional_property', `'extra: '+_k${ci}[_i]`)}}}`)
+  }
+
+  // dependentRequired
+  if (schema.dependentRequired) {
+    for (const [key, deps] of Object.entries(schema.dependentRequired)) {
+      for (const dep of deps) {
+        const p = pathExpr ? `${pathExpr}+'/${esc(dep)}'` : `'/${esc(dep)}'`
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){_e.push({code:'required_missing',path:${p},message:'${esc(key)} requires ${esc(dep)}'})}`)
+      }
+    }
+  }
+
+  // properties — use hoisted vars for required+known-object, full guard otherwise
+  if (schema.properties) {
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      const pv = hoisted[key] || `${v}[${JSON.stringify(key)}]`
+      const childPath = pathExpr ? `${pathExpr}+'/${esc(key)}'` : `'/${esc(key)}'`
+      if (requiredSet.has(key) && isObj) {
+        lines.push(`if(${pv}!==undefined){`)
+        genCodeC(prop, pv, childPath, lines, ctx)
+        lines.push(`}`)
+      } else if (isObj) {
+        const oi = ctx.varCounter++
+        lines.push(`{const _o${oi}=${v}[${JSON.stringify(key)}];if(_o${oi}!==undefined){`)
+        genCodeC(prop, `_o${oi}`, childPath, lines, ctx)
+        lines.push(`}}`)
+      } else {
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
+        genCodeC(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx)
+        lines.push(`}`)
+      }
+    }
+  }
+
+  // items
+  if (schema.items) {
+    const startIdx = schema.prefixItems ? schema.prefixItems.length : 0
+    const idx = `_j${ctx.varCounter}`, elem = `_ei${ctx.varCounter}`
+    ctx.varCounter++
+    const childPath = pathExpr ? `${pathExpr}+'/'+${idx}` : `'/'+${idx}`
+    lines.push(`if(Array.isArray(${v})){for(let ${idx}=${startIdx};${idx}<${v}.length;${idx}++){const ${elem}=${v}[${idx}]`)
+    genCodeC(schema.items, elem, childPath, lines, ctx)
+    lines.push(`}}`)
+  }
+
+  // prefixItems
+  if (schema.prefixItems) {
+    for (let i = 0; i < schema.prefixItems.length; i++) {
+      const childPath = pathExpr ? `${pathExpr}+'/${i}'` : `'/${i}'`
+      lines.push(`if(Array.isArray(${v})&&${v}.length>${i}){`)
+      genCodeC(schema.prefixItems[i], `${v}[${i}]`, childPath, lines, ctx)
+      lines.push(`}`)
+    }
+  }
+
+  // contains
+  if (schema.contains) {
+    const ci = ctx.varCounter++
+    const subLines = []
+    genCode(schema.contains, `_cv`, subLines, ctx)
+    const fnBody = subLines.length === 0 ? `return true` : `${subLines.join(';')};return true`
+    const minC = schema.minContains !== undefined ? schema.minContains : 1
+    const maxC = schema.maxContains
+    lines.push(`if(Array.isArray(${v})){const _cf${ci}=function(_cv){${fnBody}};let _cc${ci}=0;for(let _ci${ci}=0;_ci${ci}<${v}.length;_ci${ci}++){if(_cf${ci}(${v}[_ci${ci}]))_cc${ci}++}`)
+    lines.push(`if(_cc${ci}<${minC}){${fail('contains_violation', `'need ${minC}+ matches'`)}}`)
+    if (maxC !== undefined) lines.push(`if(_cc${ci}>${maxC}){${fail('contains_violation', `'max ${maxC} matches'`)}}`)
+    lines.push(`}`)
+  }
+
+  // allOf
+  if (schema.allOf) { for (const sub of schema.allOf) genCodeC(sub, v, pathExpr, lines, ctx) }
+
+  // anyOf
+  if (schema.anyOf) {
+    const fi = ctx.varCounter++
+    const fns = schema.anyOf.map(sub => { const sl = []; genCode(sub, '_av', sl, ctx); return sl.length === 0 ? `function(_av){return true}` : `function(_av){${sl.join(';')};return true}` })
+    lines.push(`{const _af${fi}=[${fns.join(',')}];let _am=false;for(let _ai=0;_ai<_af${fi}.length;_ai++){if(_af${fi}[_ai](${v})){_am=true;break}}if(!_am){${fail('any_of_failed', "'no match'")}}}`)
+  }
+
+  // oneOf
+  if (schema.oneOf) {
+    const fi = ctx.varCounter++
+    const fns = schema.oneOf.map(sub => { const sl = []; genCode(sub, '_ov', sl, ctx); return sl.length === 0 ? `function(_ov){return true}` : `function(_ov){${sl.join(';')};return true}` })
+    lines.push(`{const _of${fi}=[${fns.join(',')}];let _oc=0;for(let _oi=0;_oi<_of${fi}.length;_oi++){if(_of${fi}[_oi](${v}))_oc++;if(_oc>1)break}if(_oc!==1){${fail('one_of_failed', "'need exactly 1'")}}}`)
+  }
+
+  // not
+  if (schema.not) {
+    const sl = []; genCode(schema.not, '_nv', sl, ctx)
+    const nfn = sl.length === 0 ? `function(_nv){return true}` : `function(_nv){${sl.join(';')};return true}`
+    const fi = ctx.varCounter++
+    lines.push(`{const _nf${fi}=${nfn};if(_nf${fi}(${v})){${fail('not_failed', "'should not match'")}}}`)
+  }
+
+  // if/then/else
+  if (schema.if) {
+    const sl = []; genCode(schema.if, '_iv', sl, ctx)
+    const fi = ctx.varCounter++
+    const ifFn = sl.length === 0 ? `function(_iv){return true}` : `function(_iv){${sl.join(';')};return true}`
+    lines.push(`{const _if${fi}=${ifFn}`)
+    if (schema.then) { lines.push(`if(_if${fi}(${v})){`); genCodeC(schema.then, v, pathExpr, lines, ctx); lines.push(`}`) }
+    if (schema.else) { lines.push(`${schema.then ? 'else' : `if(!_if${fi}(${v}))`}{`); genCodeC(schema.else, v, pathExpr, lines, ctx); lines.push(`}`) }
+    lines.push(`}`)
+  }
+
+  // Close type-success block if opened
+  if (ctx._typeBlock) {
+    lines.push(`}`)
+    ctx._typeBlock = false
+  }
+}
+
+module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "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

@@ -626,6 +626,12 @@ static void validate_node(const schema_node_ptr& node,
                            std::vector<validation_error>& errors,
                            bool all_errors = true);
 
+// Fast boolean-only tree walker — no error collection, no string allocation.
+// Uses [[likely]]/[[unlikely]] hints. Returns true if valid.
+static bool validate_fast(const schema_node_ptr& node,
+                           dom::element value,
+                           const compiled_schema& ctx);
+
 // Macro for early termination
 #define ATA_CHECK_EARLY() if (!all_errors && !errors.empty()) return
 
@@ -1200,6 +1206,221 @@ static void validate_node(const schema_node_ptr& node,
   }
 }
 
+// Fast boolean-only tree walker — stripped of all error collection.
+// No std::string allocation, no path tracking, no error messages.
+// Returns true if valid. Uses [[likely]]/[[unlikely]] branch hints.
+static bool validate_fast(const schema_node_ptr& node,
+                           dom::element value,
+                           const compiled_schema& ctx) {
+  if (!node) [[unlikely]] return true;
+
+  if (node->boolean_schema.has_value()) [[unlikely]]
+    return node->boolean_schema.value();
+
+  // $ref
+  if (!node->ref.empty()) [[unlikely]] {
+    auto it = ctx.defs.find(node->ref);
+    if (it != ctx.defs.end()) {
+      if (!validate_fast(it->second, value, ctx)) return false;
+    } else if (node->ref == "#" && ctx.root) {
+      if (!validate_fast(ctx.root, value, ctx)) return false;
+    } else {
+      return false;
+    }
+  }
+
+  // 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;
+  }
+
+  // enum
+  if (!node->enum_values_minified.empty()) {
+    auto val_str = canonical_json(value);
+    bool found = false;
+    for (const auto& ev : node->enum_values_minified) {
+      if (ev == val_str) { found = true; break; }
+    }
+    if (!found) [[unlikely]] return false;
+  }
+
+  // const
+  if (node->const_value_raw.has_value()) {
+    if (canonical_json(value) != node->const_value_raw.value()) [[unlikely]] return false;
+  }
+
+  auto actual_type = type_of_sv(value);
+
+  // Numeric
+  if (actual_type == "integer" || actual_type == "number") {
+    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;
+    if (node->exclusive_minimum.has_value() && v <= node->exclusive_minimum.value()) return false;
+    if (node->exclusive_maximum.has_value() && v >= node->exclusive_maximum.value()) return false;
+    if (node->multiple_of.has_value()) {
+      double rem = std::fmod(v, node->multiple_of.value());
+      if (std::abs(rem) > 1e-8 && std::abs(rem - node->multiple_of.value()) > 1e-8) return false;
+    }
+  }
+
+  // String
+  if (actual_type == "string") {
+    std::string_view sv;
+    value.get(sv);
+    uint64_t len = utf8_length(sv);
+    if (node->min_length.has_value() && len < node->min_length.value()) return false;
+    if (node->max_length.has_value() && len > node->max_length.value()) return false;
+    if (node->compiled_pattern) {
+      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;
+  }
+
+  // Array
+  if (actual_type == "array" && value.is<dom::array>()) {
+    dom::array arr; value.get(arr);
+    uint64_t 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;
+      }
+    }
+
+    { uint64_t idx = 0;
+      for (auto item : arr) {
+        if (idx < node->prefix_items.size()) {
+          if (!validate_fast(node->prefix_items[idx], item, ctx)) return false;
+        } else if (node->items_schema) {
+          if (!validate_fast(node->items_schema, item, ctx)) return false;
+        }
+        ++idx;
+      }
+    }
+
+    if (node->contains_schema) {
+      uint64_t match_count = 0;
+      for (auto item : arr) {
+        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);
+      if (match_count < min_c || match_count > max_c) return false;
+    }
+  }
+
+  // Object
+  if (actual_type == "object" && value.is<dom::object>()) {
+    dom::object obj; value.get(obj);
+
+    if (node->min_properties.has_value() || node->max_properties.has_value()) {
+      uint64_t n = 0;
+      for ([[maybe_unused]] auto _ : obj) ++n;
+      if (node->min_properties.has_value() && n < node->min_properties.value()) return false;
+      if (node->max_properties.has_value() && n > node->max_properties.value()) return false;
+    }
+
+    for (const auto& req : node->required) {
+      dom::element d;
+      if (obj[req].get(d) != SUCCESS) [[unlikely]] return false;
+    }
+
+    for (auto [key, val] : obj) {
+      std::string_view key_sv(key);
+      bool matched = false;
+
+      auto it = node->properties.find(std::string(key_sv));
+      if (it != node->properties.end()) {
+        if (!validate_fast(it->second, val, ctx)) return false;
+        matched = true;
+      }
+
+      for (const auto& pp : node->pattern_properties) {
+        if (pp.compiled && re2::RE2::PartialMatch(
+            re2::StringPiece(key_sv.data(), key_sv.size()), *pp.compiled)) {
+          if (!validate_fast(pp.schema, val, ctx)) return false;
+          matched = true;
+        }
+      }
+
+      if (!matched) {
+        if (node->additional_properties_bool.has_value() &&
+            !node->additional_properties_bool.value()) return false;
+        if (node->additional_properties_schema &&
+            !validate_fast(node->additional_properties_schema, val, ctx)) return false;
+      }
+    }
+
+    for (const auto& [prop, deps] : node->dependent_required) {
+      dom::element d;
+      if (obj[prop].get(d) == SUCCESS) {
+        for (const auto& dep : deps) {
+          dom::element dd;
+          if (obj[dep].get(dd) != SUCCESS) return false;
+        }
+      }
+    }
+
+    for (const auto& [prop, schema] : node->dependent_schemas) {
+      dom::element d;
+      if (obj[prop].get(d) == SUCCESS) {
+        if (!validate_fast(schema, value, ctx)) return false;
+      }
+    }
+  }
+
+  // allOf
+  for (const auto& sub : node->all_of) {
+    if (!validate_fast(sub, value, ctx)) return false;
+  }
+
+  // anyOf
+  if (!node->any_of.empty()) {
+    bool any = false;
+    for (const auto& sub : node->any_of) {
+      if (validate_fast(sub, value, ctx)) { any = true; break; }
+    }
+    if (!any) return false;
+  }
+
+  // oneOf
+  if (!node->one_of.empty()) {
+    int n = 0;
+    for (const auto& sub : node->one_of) {
+      if (validate_fast(sub, value, ctx)) ++n;
+      if (n > 1) return false;
+    }
+    if (n != 1) return false;
+  }
+
+  // not
+  if (node->not_schema) {
+    if (validate_fast(node->not_schema, value, ctx)) return false;
+  }
+
+  // if/then/else
+  if (node->if_schema) {
+    if (validate_fast(node->if_schema, value, ctx)) {
+      if (node->then_schema && !validate_fast(node->then_schema, value, ctx)) return false;
+    } else {
+      if (node->else_schema && !validate_fast(node->else_schema, value, ctx)) return false;
+    }
+  }
+
+  return true;
+}
+
 // --- Codegen compiler ---
 static void cg_compile(const schema_node* n, cg::plan& p,
                         std::vector<cg::ins>& out) {
@@ -1660,9 +1881,8 @@ bool is_valid_prepadded(const schema_ref& schema, const char* data, size_t lengt
     return cg_exec(schema.impl->gen_plan, schema.impl->gen_plan.code, result.value());
   }
 
-  std::vector<validation_error> errors;
-  validate_node(schema.impl->root, result.value(), "", *schema.impl, errors, false);
-  return errors.empty();
+  // Use fast boolean-only tree walker — no error collection overhead
+  return validate_fast(schema.impl->root, result.value(), *schema.impl);
 }
 
 }  // namespace ata