ata-validator 0.4.7 → 0.4.9

package/README.md

@@ -10,12 +10,14 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **validate(obj)** valid | 15M ops/sec | 8M ops/sec | **ata 1.9x faster** |
-| **validate(obj)** invalid | 13.1M ops/sec | 8.1M ops/sec | **ata 1.6x faster** |
+| **validate(obj)** valid | 76M ops/sec | 8M ops/sec | **ata 9.5x faster** |
+| **validate(obj)** invalid | 34M ops/sec | 8M ops/sec | **ata 4.3x faster** |
 | **isValidObject(obj)** | 15.4M ops/sec | 9.2M ops/sec | **ata 1.7x faster** |
 | **validateJSON(str)** valid | 2.15M ops/sec | 1.88M ops/sec | **ata 1.1x faster** |
-| **validateJSON(str)** invalid | 2.62M ops/sec | 2.35M ops/sec | **ata 1.1x faster** |
-| **Schema compilation** | 112K ops/sec | 773 ops/sec | **ata 145x faster** |
+| **validateJSON(str)** invalid | 2.17M ops/sec | 2.29M ops/sec | **ata 1.1x faster** |
+| **Schema compilation** | 113K ops/sec | 818 ops/sec | **ata 138x faster** |
+
+> validate(obj) numbers are isolated single-schema benchmarks. Multi-schema benchmark overhead reduces throughput; real-world numbers depend on workload.
 
 ### Large Data — JS Object Validation
 
@@ -38,7 +40,7 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ### How it works
 
-**Combined single-pass validation**: ata compiles schemas into monolithic JS functions that both validate and collect errors in a single pass. Valid data returns immediately (lazy error array — zero allocation). Invalid data collects errors without a second pass.
+**Hybrid validator**: ata compiles schemas into monolithic JS functions identical to the boolean fast path, but returning `VALID_RESULT` on success and calling the error collector on failure. V8 TurboFan optimizes it identically to a pure boolean function — error code is dead code on the valid path. No try/catch (3.3x V8 deopt), no lazy arrays, no double-pass.
 
 **JS codegen**: Schemas are compiled to monolithic JS functions (like ajv). Supported keywords: `type`, `required`, `properties`, `items`, `enum`, `const`, `allOf`, `anyOf`, `oneOf`, `not`, `if/then/else`, `uniqueItems`, `contains`, `prefixItems`, `additionalProperties`, `dependentRequired`, `$ref` (local), `minimum/maximum`, `minLength/maxLength`, `pattern`, `format`.
 
@@ -52,7 +54,7 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ## When to use ata
 
-- **Any `validate(obj)` workload** — 1.6x–2.7x faster than ajv on all data
+- **Any `validate(obj)` workload** — 4.3x–9.5x faster than ajv
 - **Serverless / cold starts** — 12.5x faster schema compilation
 - **Security-sensitive apps** — RE2 regex, immune to ReDoS attacks
 - **Batch/streaming validation** — NDJSON log processing, data pipelines (2.6x faster)
@@ -66,7 +68,7 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ## Features
 
-- **Combined single-pass validation**: One JS function validates + collects errors — no double pass, lazy error allocation
+- **Hybrid validator**: 76M ops/sec — same function body as boolean check, returns result or calls error collector. No try/catch, no double pass
 - **Multi-core**: Parallel validation across all CPU cores — 13.4M validations/sec
 - **simdjson**: SIMD-accelerated JSON parsing at GB/s speeds, adaptive On Demand for large docs
 - **RE2 regex**: Linear-time guarantees, immune to ReDoS attacks (2391x faster on pathological input)
@@ -101,7 +103,7 @@ const v = new Validator({
   required: ['name', 'email']
 });
 
-// Fast boolean check — JS codegen (1.7x faster than ajv)
+// Fast boolean check — JS codegen (9.5x faster than ajv)
 v.isValidObject({ name: 'Mert', email: 'mert@example.com', age: 26 }); // true
 
 // Full validation with error details + defaults applied

package/binding/ata_napi.cpp

@@ -1048,7 +1048,7 @@ static ThreadPool& pool() {
 
 // --- Fast Validation Registry ---
 // Global schema slots for V8 Fast API (bypasses NAPI overhead)
-static constexpr size_t MAX_FAST_SLOTS = 256;
+static constexpr size_t MAX_FAST_SLOTS = 4096;
 static ata::schema_ref g_fast_schemas[MAX_FAST_SLOTS];
 static std::string g_fast_schema_jsons[MAX_FAST_SLOTS];
 static uint32_t g_fast_slot_count = 0;

package/binding.gyp

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

package/index.js

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

package/lib/js-compiler.js

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

package/package.json

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

package/src/ata.cpp

@@ -1,5 +1,10 @@
 #include "ata.h"
 
+// mimalloc: faster new/delete for small allocations.
+#if __has_include(<mimalloc-new-delete.h>)
+#include <mimalloc-new-delete.h>
+#endif
+
 #include <algorithm>
 #include <cmath>
 #include <re2/re2.h>