ata-validator 0.4.6 → 0.4.7

package/index.js

@@ -219,9 +219,9 @@ class Validator {
       ? 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;
+    const jsErrFn = process.env.ATA_FORCE_NAPI
+      ? null
+      : compileToJSCodegenWithErrors(schemaObj);
     this._jsFn = jsFn;
 
     // Data mutators — applied in-place before validation
@@ -254,20 +254,28 @@ class Validator {
       // Valid data: no array allocation, returns VALID_RESULT
       // Invalid data: collects errors in one pass (no double validation)
       // Fallback: jsFn + errFn for schemas combined can't handle
-      const errFn = jsErrFn
-        ? (d) => { try { return jsErrFn(d, true); } catch { return compiled.validate(d); } }
-        : (d) => compiled.validate(d);
-      this.validate = jsCombinedFn
-        ? (preprocess
-            ? (data) => { preprocess(data); try { return jsCombinedFn(data); } catch { return jsFn(data) ? VALID_RESULT : errFn(data); } }
-            : (data) => { try { return jsCombinedFn(data); } catch { return jsFn(data) ? VALID_RESULT : errFn(data); } })
+      // errFn: JS error codegen or NAPI fallback. No try/catch (V8 3.3x deopt).
+      // jsErrFn tested at compile time — if it throws, don't use it.
+      let safeErrFn = null;
+      if (jsErrFn) {
+        try { jsErrFn({}, true); safeErrFn = (d) => jsErrFn(d, true); } catch {}
+      }
+      const errFn = safeErrFn || ((d) => compiled.validate(d));
+
+      // Hybrid validator: jsFn body with return R / return E(d).
+      // V8 optimizes identically to jsFn (83M) — E(d) is dead code on valid path.
+      // Invalid: E(d) calls errFn once (34M vs 6M two-pass).
+      // Fallback: jsFn + errFn speculative if hybrid unavailable.
+      const hybridFn = jsFn._hybridFactory
+        ? jsFn._hybridFactory(VALID_RESULT, errFn)
+        : null;
+      this.validate = hybridFn
+        ? (preprocess ? (data) => { preprocess(data); return hybridFn(data); } : hybridFn)
         : (preprocess
             ? (data) => { preprocess(data); return jsFn(data) ? VALID_RESULT : errFn(data); }
             : (data) => jsFn(data) ? VALID_RESULT : errFn(data));
       this.isValidObject = jsFn;
-      const jsonValidateFn = jsCombinedFn
-        ? (obj) => { try { return jsCombinedFn(obj); } catch { return jsFn(obj) ? VALID_RESULT : errFn(obj); } }
-        : (obj) => jsFn(obj) ? VALID_RESULT : errFn(obj);
+      const jsonValidateFn = hybridFn || ((obj) => jsFn(obj) ? VALID_RESULT : errFn(obj));
       this.validateJSON = useSimdjsonForLarge
         ? (jsonStr) => {
             if (jsonStr.length >= SIMDJSON_THRESHOLD) {

package/lib/js-compiler.js

@@ -528,12 +528,57 @@ function compileToJSCodegen(schema) {
   const body = helperStr + checkStr + '\n  return true'
 
   try {
-    return new Function('d', body)
+    const boolFn = new Function('d', body)
+
+    // Build hybrid: same body, return R instead of true, return E(d) instead of false.
+    // V8 optimizes this identically to jsFn — E(d) is dead code on valid path.
+    // 83M ops/sec vs 26M for combined. Invalid path: 34M vs 6M.
+    const hybridBody = replaceTopLevel(helperStr + checkStr + '\n  return R')
+    try {
+      const factory = new Function('R', 'E', `return function(d){${hybridBody}}`)
+      boolFn._hybridFactory = factory
+    } catch {}
+
+    return boolFn
   } catch {
     return null
   }
 }
 
+// Replace top-level `return false` → `return E(d)` and `return true` → `return R`.
+// Tracks function nesting depth to preserve nested function internals.
+function replaceTopLevel(code) {
+  let fnDepth = 0, result = '', i = 0
+  while (i < code.length) {
+    if (code.startsWith('function', i) && (i === 0 || /[^a-zA-Z_$]/.test(code[i - 1]))) {
+      // Found a nested function — skip to opening brace, track all braces inside
+      let j = i + 8
+      while (j < code.length && code[j] !== '{') j++
+      result += code.slice(i, j + 1)
+      i = j + 1
+      // Track braces inside this function body
+      let braceDepth = 1
+      while (i < code.length && braceDepth > 0) {
+        if (code[i] === '{') braceDepth++
+        else if (code[i] === '}') braceDepth--
+        if (braceDepth > 0) result += code[i]
+        else result += '}'  // closing brace of function
+        i++
+      }
+    } else if (code.startsWith('return false', i)) {
+      result += 'return E(d)'
+      i += 12
+    } else if (code.startsWith('return true', i) && (i + 11 >= code.length || !/[a-zA-Z_$]/.test(code[i + 11]))) {
+      result += 'return R'
+      i += 11
+    } else {
+      result += code[i]
+      i++
+    }
+  }
+  return result
+}
+
 // knownType: if parent already verified the type, skip redundant guards.
 // 'object' = we know v is a non-null non-array object
 // 'array'  = we know v is an array

package/package.json

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