ata-validator 0.4.10 → 0.4.12

package/README.md

@@ -10,16 +10,16 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **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** |
+| **validate(obj)** valid | 68M ops/sec | 8M ops/sec | **ata 8.5x faster** |
+| **validate(obj)** invalid | 17M ops/sec | 8M ops/sec | **ata 2.1x 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.17M ops/sec | 2.29M ops/sec | **ata 1.1x faster** |
+| **validateJSON(str)** valid | 3.0M ops/sec | 1.9M ops/sec | **ata 1.6x faster** |
+| **validateJSON(str)** invalid | 2.7M ops/sec | 2.3M ops/sec | **ata 1.2x 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
+### Large Data - JS Object Validation
 
 | Size | ata | ajv | |
 |---|---|---|---|
@@ -35,18 +35,19 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 | **ReDoS protection** (`^(a+)+$`) | 0.3ms | 765ms | **ata immune (RE2)** |
 | **Batch NDJSON** (10K items, multi-core) | 13.4M/sec | 5.1M/sec | **ata 2.6x faster** |
 | **Fastify HTTP** (100 users POST) | 24.6K req/sec | 22.6K req/sec | **ata 9% faster** |
+| **Fastify startup** (500 routes) | 46ms | 77ms (standalone) | **ata 1.7x faster** |
 
-> ata is faster than ajv on **every** benchmark — valid and invalid data, objects and JSON strings, single documents and parallel batches.
+> Isolated single-schema benchmarks. Results vary by workload and hardware.
 
 ### How it works
 
-**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.
+**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`.
 
 **V8 TurboFan optimizations**: Destructuring batch reads, `undefined` checks instead of `in` operator, context-aware type guard elimination, property hoisting to local variables, tiered uniqueItems (nested loop for small arrays).
 
-**Adaptive simdjson**: For large documents (>8KB) with selective schemas, simdjson On Demand seeks only the needed fields — skipping irrelevant data at GB/s speeds.
+**Adaptive simdjson**: For large documents (>8KB) with selective schemas, simdjson On Demand seeks only the needed fields - skipping irrelevant data at GB/s speeds.
 
 ### JSON Schema Test Suite
 
@@ -54,27 +55,27 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ## When to use ata
 
-- **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)
-- **Standard Schema V1** — native support for Fastify v5, tRPC, TanStack
-- **C/C++ embedding** — native library, no JS runtime needed
+- **High-throughput `validate(obj)`** - 68M ops/sec valid, 17M ops/sec invalid
+- **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)
+- **Standard Schema V1** - native support for Fastify v5, tRPC, TanStack
+- **C/C++ embedding** - native library, no JS runtime needed
 
 ## When to use ajv
 
-- **Schemas with `patternProperties`, `dependentSchemas`** — these bypass JS codegen and hit the slower NAPI path
-- **100% spec compliance needed** — ajv covers more edge cases (ata: 98.4%)
+- **Schemas with `patternProperties`, `dependentSchemas`** - these bypass JS codegen and hit the slower NAPI path
+- **100% spec compliance needed** - ajv covers more edge cases (ata: 98.4%)
 
 ## Features
 
-- **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
+- **Hybrid validator**: 68M 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)
 - **V8-optimized codegen**: Destructuring batch reads, type guard elimination, property hoisting
 - **Standard Schema V1**: Compatible with Fastify, tRPC, TanStack, Drizzle
-- **Zero-copy paths**: Buffer and pre-padded input support — no unnecessary copies
+- **Zero-copy paths**: Buffer and pre-padded input support - no unnecessary copies
 - **Defaults + coercion**: `default` values, `coerceTypes`, `removeAdditional` support
 - **C/C++ library**: Native API for non-Node.js environments
 - **98.4% spec compliant**: Draft 2020-12
@@ -103,7 +104,7 @@ const v = new Validator({
   required: ['name', 'email']
 });
 
-// Fast boolean check — JS codegen (9.5x faster than ajv)
+// Fast boolean check - JS codegen, 68M ops/sec
 v.isValidObject({ name: 'Mert', email: 'mert@example.com', age: 26 }); // true
 
 // Full validation with error details + defaults applied
@@ -117,7 +118,7 @@ v.isValidJSON('{"name": "Mert", "email": "mert@example.com"}'); // true
 // Buffer input (zero-copy, raw NAPI)
 v.isValid(Buffer.from('{"name": "Mert", "email": "mert@example.com"}'));
 
-// Parallel batch — multi-core, NDJSON (2.6x faster than ajv)
+// Parallel batch - multi-core, NDJSON, 13.4M items/sec
 const ndjson = Buffer.from(lines.join('\n'));
 v.isValidParallel(ndjson);  // bool[]
 v.countValid(ndjson);        // number
@@ -132,6 +133,27 @@ const v = new Validator(schema, {
 });
 ```
 
+### Standalone Pre-compilation
+
+Pre-compile schemas to JS files for near-zero startup. No native addon needed at runtime.
+
+```javascript
+const fs = require('fs');
+
+// Build phase (once)
+const v = new Validator(schema);
+fs.writeFileSync('./compiled.js', v.toStandalone());
+
+// Read phase (every startup) - 0.6μs per schema, pure JS
+const v2 = Validator.fromStandalone(require('./compiled.js'), schema);
+
+// Bundle multiple schemas - deduplicated, single file
+fs.writeFileSync('./bundle.js', Validator.bundleCompact(schemas));
+const validators = Validator.loadBundle(require('./bundle.js'), schemas);
+```
+
+**Fastify startup (500 routes): ajv standalone 77ms → ata standalone 46ms (1.7x faster)**
+
 ### Standard Schema V1
 
 ```javascript

package/index.js

@@ -1,10 +1,15 @@
 const native = require("node-gyp-build")(__dirname);
-const { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined } = 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.
 function buildDefaultsApplier(schema) {
-  if (typeof schema !== 'object' || schema === null) return null;
+  if (typeof schema !== "object" || schema === null) return null;
   const actions = [];
   collectDefaults(schema, actions);
   if (actions.length === 0) return null;
@@ -14,17 +19,19 @@ function buildDefaultsApplier(schema) {
 }
 
 function collectDefaults(schema, actions, path) {
-  if (typeof schema !== 'object' || schema === null) return;
+  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.default !== undefined) {
+    if (prop && typeof prop === "object" && prop.default !== undefined) {
       const defaultVal = prop.default;
       if (!path) {
         actions.push((data) => {
-          if (typeof data === 'object' && data !== null && !(key in data)) {
-            data[key] = typeof defaultVal === 'object' && defaultVal !== null
-              ? JSON.parse(JSON.stringify(defaultVal)) : defaultVal;
+          if (typeof data === "object" && data !== null && !(key in data)) {
+            data[key] =
+              typeof defaultVal === "object" && defaultVal !== null
+                ? JSON.parse(JSON.stringify(defaultVal))
+                : defaultVal;
           }
         });
       } else {
@@ -32,18 +39,24 @@ function collectDefaults(schema, actions, path) {
         actions.push((data) => {
           let target = data;
           for (let j = 0; j < parentPath.length; j++) {
-            if (typeof target !== 'object' || target === null) return;
+            if (typeof target !== "object" || target === null) return;
             target = target[parentPath[j]];
           }
-          if (typeof target === 'object' && target !== null && !(key in target)) {
-            target[key] = typeof defaultVal === 'object' && defaultVal !== null
-              ? JSON.parse(JSON.stringify(defaultVal)) : defaultVal;
+          if (
+            typeof target === "object" &&
+            target !== null &&
+            !(key in target)
+          ) {
+            target[key] =
+              typeof defaultVal === "object" && defaultVal !== null
+                ? JSON.parse(JSON.stringify(defaultVal))
+                : defaultVal;
           }
         });
       }
     }
     // Recurse into nested object schemas
-    if (prop && typeof prop === 'object' && prop.properties) {
+    if (prop && typeof prop === "object" && prop.properties) {
       collectDefaults(prop, actions, (path || []).concat(key));
     }
   }
@@ -52,7 +65,7 @@ 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;
+  if (typeof schema !== "object" || schema === null) return null;
   const actions = [];
   collectCoercions(schema, actions);
   if (actions.length === 0) return null;
@@ -62,11 +75,11 @@ function buildCoercer(schema) {
 }
 
 function collectCoercions(schema, actions, path) {
-  if (typeof schema !== 'object' || schema === null) return;
+  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;
+    if (!prop || typeof prop !== "object" || !prop.type) continue;
     const targetType = Array.isArray(prop.type) ? null : prop.type;
     if (!targetType) continue;
 
@@ -75,7 +88,7 @@ function collectCoercions(schema, actions, path) {
 
     if (!path) {
       actions.push((data) => {
-        if (typeof data === 'object' && data !== null && key in data) {
+        if (typeof data === "object" && data !== null && key in data) {
           const coerced = coerce(data[key]);
           if (coerced !== undefined) data[key] = coerced;
         }
@@ -85,10 +98,10 @@ function collectCoercions(schema, actions, path) {
       actions.push((data) => {
         let target = data;
         for (let j = 0; j < parentPath.length; j++) {
-          if (typeof target !== 'object' || target === null) return;
+          if (typeof target !== "object" || target === null) return;
           target = target[parentPath[j]];
         }
-        if (typeof target === 'object' && target !== null && key in target) {
+        if (typeof target === "object" && target !== null && key in target) {
           const coerced = coerce(target[key]);
           if (coerced !== undefined) target[key] = coerced;
         }
@@ -104,29 +117,40 @@ function collectCoercions(schema, actions, path) {
 
 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;
+    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;
+  if (typeof schema !== "object" || schema === null) return null;
   const actions = [];
   collectRemovals(schema, actions);
   if (actions.length === 0) return null;
@@ -136,14 +160,16 @@ function buildRemover(schema) {
 }
 
 function collectRemovals(schema, actions, path) {
-  if (typeof schema !== 'object' || schema === null || !schema.properties) return;
+  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;
+        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]];
@@ -154,10 +180,15 @@ function collectRemovals(schema, actions, path) {
       actions.push((data) => {
         let target = data;
         for (let j = 0; j < parentPath.length; j++) {
-          if (typeof target !== 'object' || target === null) return;
+          if (typeof target !== "object" || target === null) return;
           target = target[parentPath[j]];
         }
-        if (typeof target !== 'object' || target === null || Array.isArray(target)) return;
+        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]];
@@ -168,7 +199,7 @@ function collectRemovals(schema, actions, path) {
 
   // 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) {
+    if (prop && typeof prop === "object" && prop.properties) {
       collectRemovals(prop, actions, (path || []).concat(key));
     }
   }
@@ -204,147 +235,277 @@ class Validator {
     const options = opts || {};
     const schemaStr =
       typeof schema === "string" ? schema : JSON.stringify(schema);
-    const compiled = new native.CompiledSchema(schemaStr);
-    this._compiled = compiled;
-    this._fastSlot = native.fastRegister(schemaStr);
-
-    // 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._schemaStr = schemaStr;
     this._schemaObj = schemaObj;
+    this._options = options;
+    this._initialized = false;
+    this._nativeReady = false;
+    this._compiled = null;
+    this._fastSlot = -1;
+    this._jsFn = null;
+    this._preprocess = null;
+    this._applyDefaults = null;
+
+    // Lazy stubs: trigger compilation on first call, then re-dispatch
+    this.validate = (data) => {
+      this._ensureCompiled();
+      return this.validate(data);
+    };
+    this.isValidObject = (data) => {
+      this._ensureCompiled();
+      return this.isValidObject(data);
+    };
+    this.validateJSON = (jsonStr) => {
+      this._ensureCompiled();
+      return this.validateJSON(jsonStr);
+    };
+    this.isValidJSON = (jsonStr) => {
+      this._ensureCompiled();
+      return this.isValidJSON(jsonStr);
+    };
+
+    // ~standard uses self.validate() -- works with lazy because it goes through
+    // the instance property which gets swapped after compilation
+    const self = this;
+    Object.defineProperty(this, "~standard", {
+      value: Object.freeze({
+        version: 1,
+        vendor: "ata-validator",
+        validate(value) {
+          const result = self.validate(value);
+          if (result.valid) {
+            return { value };
+          }
+          return {
+            issues: result.errors.map((err) => ({
+              message: err.message,
+              path: parsePointerPath(err.path),
+            })),
+          };
+        },
+      }),
+      writable: false,
+      enumerable: false,
+      configurable: false,
+    });
+  }
+
+  _ensureCompiled() {
+    if (this._initialized) return;
+    this._initialized = true;
+
+    const schemaObj = this._schemaObj;
+    const options = this._options;
+
+    // Pure JS fast path -- no NAPI, runs in V8 JIT
+    // Set ATA_FORCE_NAPI=1 to disable JS codegen (for correctness testing)
     const jsFn = process.env.ATA_FORCE_NAPI
       ? null
-      : (compileToJSCodegen(schemaObj) || compileToJS(schemaObj));
-    // Combined validator: single pass, validates + collects errors, all optimized
+      : compileToJSCodegen(schemaObj) || compileToJS(schemaObj);
     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 = process.env.ATA_FORCE_NAPI
       ? null
       : compileToJSCodegenWithErrors(schemaObj);
     this._jsFn = jsFn;
 
-    // Data mutators — applied in-place before validation
+    // 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;
+    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); };
+    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;
-
-    // Detect if schema is "selective" — doesn't recurse into arrays/deep objects.
-    // Selective schemas benefit from simdjson On Demand (seeks only needed fields).
-    // Non-selective schemas (items, allOf with nested) touch everything — JSON.parse + jsFn wins.
-    const hasArrayTraversal = schemaObj && (schemaObj.items || schemaObj.prefixItems ||
-      schemaObj.contains || (schemaObj.properties && Object.values(schemaObj.properties).some(
-        p => p && (p.items || p.prefixItems || p.contains))));
+    // Detect if schema is "selective" -- doesn't recurse into arrays/deep objects.
+    const hasArrayTraversal =
+      schemaObj &&
+      (schemaObj.items ||
+        schemaObj.prefixItems ||
+        schemaObj.contains ||
+        (schemaObj.properties &&
+          Object.values(schemaObj.properties).some(
+            (p) => p && (p.items || p.prefixItems || p.contains),
+          )));
     const useSimdjsonForLarge = !hasArrayTraversal;
 
     if (jsFn) {
-      // Best path: combined validator (single pass, lazy error array)
-      // 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
-      // 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 {}
+        try {
+          jsErrFn({}, true);
+          safeErrFn = (d) => jsErrFn(d, true);
+        } catch {}
+      }
+      // errFn: use JS codegen if safe, else lazy-native fallback
+      const errFn =
+        safeErrFn ||
+        ((d) => {
+          this._ensureNative();
+          return this._compiled.validate(d);
+        });
+
+      // Best path: combined validator (single pass, validates + collects errors)
+      // Valid data: returns VALID_RESULT, no allocation
+      // Invalid data: collects errors in one pass (no double validation)
+      // Fallback: hybridFn or jsFn + errFn for schemas combined can't handle
+      // Test combined at compile time -- some schemas produce broken combined code
+      // Test combined at compile time -- some schemas (e.g. if/then/else)
+      // produce broken combined code that crashes on certain inputs.
+      // We probe with diverse data; if any throws, fall back to hybrid.
+      let safeCombinedFn = null;
+      if (jsCombinedFn) {
+        try {
+          const probe = {};
+          // Populate probe with one key per known property to trigger nested paths
+          if (schemaObj && schemaObj.properties) {
+            for (const k of Object.keys(schemaObj.properties)) probe[k] = "";
+          }
+          if (schemaObj && schemaObj.if && schemaObj.if.properties) {
+            for (const k of Object.keys(schemaObj.if.properties)) probe[k] = "";
+          }
+          jsCombinedFn(probe);
+          jsCombinedFn({});
+          jsCombinedFn(null);
+          jsCombinedFn(0);
+          safeCombinedFn = jsCombinedFn;
+        } 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.
+      if (safeCombinedFn) {
+        this.validate = preprocess
+          ? (data) => {
+              preprocess(data);
+              return safeCombinedFn(data);
+            }
+          : safeCombinedFn;
+      } else {
+        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 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 = hybridFn || ((obj) => jsFn(obj) ? VALID_RESULT : errFn(obj));
+      const jsonValidateFn = safeCombinedFn
+        || hybridFn
+        || ((obj) => (jsFn(obj) ? VALID_RESULT : errFn(obj)));
       this.validateJSON = useSimdjsonForLarge
         ? (jsonStr) => {
             if (jsonStr.length >= SIMDJSON_THRESHOLD) {
+              this._ensureNative();
               const buf = Buffer.from(jsonStr);
-              if (native.rawFastValidate(fastSlot, buf)) return VALID_RESULT;
-              return compiled.validateJSON(jsonStr);
+              if (native.rawFastValidate(this._fastSlot, buf))
+                return VALID_RESULT;
+              return this._compiled.validateJSON(jsonStr);
+            }
+            try {
+              return jsonValidateFn(JSON.parse(jsonStr));
+            } 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._ensureNative();
+            return this._compiled.validateJSON(jsonStr);
           }
         : (jsonStr) => {
-            try { return jsonValidateFn(JSON.parse(jsonStr)); }
-            catch (e) { if (!(e instanceof SyntaxError)) throw e; }
-            return compiled.validateJSON(jsonStr);
+            try {
+              return jsonValidateFn(JSON.parse(jsonStr));
+            } catch (e) {
+              if (!(e instanceof SyntaxError)) throw e;
+            }
+            this._ensureNative();
+            return this._compiled.validateJSON(jsonStr);
           };
       this.isValidJSON = useSimdjsonForLarge
         ? (jsonStr) => {
             if (jsonStr.length >= SIMDJSON_THRESHOLD) {
-              return native.rawFastValidate(fastSlot, Buffer.from(jsonStr));
+              this._ensureNative();
+              return native.rawFastValidate(
+                this._fastSlot,
+                Buffer.from(jsonStr),
+              );
+            }
+            try {
+              return jsFn(JSON.parse(jsonStr));
+            } catch (e) {
+              if (!(e instanceof SyntaxError)) throw e;
+              return false;
             }
-            try { return jsFn(JSON.parse(jsonStr)); }
-            catch (e) { if (!(e instanceof SyntaxError)) throw e; return false; }
           }
         : (jsonStr) => {
-            try { return jsFn(JSON.parse(jsonStr)); }
-            catch (e) { if (!(e instanceof SyntaxError)) throw e; return false; }
+            try {
+              return jsFn(JSON.parse(jsonStr));
+            } catch (e) {
+              if (!(e instanceof SyntaxError)) throw e;
+              return false;
+            }
           };
+    } else {
+      // ATA_FORCE_NAPI path: no JS codegen, use native for everything
+      this._ensureNative();
+      this.validate = preprocess
+        ? (data) => {
+            preprocess(data);
+            return this._compiled.validate(data);
+          }
+        : (data) => this._compiled.validate(data);
+      this.isValidObject = (data) => this._compiled.validate(data).valid;
+      this.validateJSON = (jsonStr) => this._compiled.validateJSON(jsonStr);
+      this.isValidJSON = (jsonStr) => this._compiled.isValidJSON(jsonStr);
     }
+  }
 
-    const self = this;
-    Object.defineProperty(this, "~standard", {
-      value: Object.freeze({
-        version: 1,
-        vendor: "ata-validator",
-        validate(value) {
-          const result = self.validate(value);
-          if (result.valid) {
-            return { value };
-          }
-          return {
-            issues: result.errors.map((err) => ({
-              message: err.message,
-              path: parsePointerPath(err.path),
-            })),
-          };
-        },
-      }),
-      writable: false,
-      enumerable: false,
-      configurable: false,
-    });
+  _ensureNative() {
+    if (this._nativeReady) return;
+    this._nativeReady = true;
+    this._compiled = new native.CompiledSchema(this._schemaStr);
+    this._fastSlot = native.fastRegister(this._schemaStr);
   }
 
   // --- 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.
+  // On next startup, load with Validator.fromStandalone() -- zero compile time.
   toStandalone() {
+    this._ensureCompiled();
     const jsFn = this._jsFn;
     if (!jsFn || !jsFn._source) return null;
     const src = jsFn._source;
-    const hybridSrc = jsFn._hybridSource || '';
+    const hybridSrc = jsFn._hybridSource || "";
 
     // Also capture error function source for zero-compile standalone load
     const jsErrFn = compileToJSCodegenWithErrors(
-      typeof this._schemaObj === 'object' ? this._schemaObj : {}
+      typeof this._schemaObj === "object" ? this._schemaObj : {},
     );
-    const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : '';
+    const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : "";
 
     return `// Auto-generated by ata-validator — do not edit
 'use strict';
@@ -356,7 +517,7 @@ const hybridFactory = function(R, E) {
     ${hybridSrc}
   };
 };
-${errSrc ? `const errFn = function(d, _all) {\n  ${errSrc}\n};` : 'const errFn = null;'}
+${errSrc ? `const errFn = function(d, _all) {\n  ${errSrc}\n};` : "const errFn = null;"}
 module.exports = { boolFn, hybridFactory, errFn };
 `;
   }
@@ -377,21 +538,36 @@ module.exports = { boolFn, hybridFactory, errFn };
     // Mutators
     const applyDefaults = buildDefaultsApplier(schemaObj);
     const applyCoerce = options.coerceTypes ? buildCoercer(schemaObj) : null;
-    const applyRemove = options.removeAdditional ? buildRemover(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); };
+    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' }] });
+    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 {}
+        try {
+          jsErrFn({}, true);
+          errFn = (d) => jsErrFn(d, true);
+        } catch {}
       }
     }
 
@@ -401,77 +577,93 @@ module.exports = { boolFn, hybridFactory, 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));
+      ? 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; }
+      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' }] }; }
+        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",
+        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) })) };
+          return {
+            issues: result.errors.map((e) => ({
+              message: e.message,
+              path: parsePointerPath(e.path),
+            })),
+          };
         },
       }),
-      writable: false, enumerable: false, configurable: false,
+      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);
-    return this._compiled.validate(data);
-  }
-
-  isValidObject(data) {
-    return this._compiled.validate(data).valid;
-  }
-
-  validateJSON(jsonStr) {
-    return this._compiled.validateJSON(jsonStr);
-  }
-
-  isValidJSON(jsonStr) {
-    return this._compiled.isValidJSON(jsonStr);
-  }
-
   // Raw NAPI fast path for Buffer/Uint8Array
   isValid(input) {
+    this._ensureNative();
     return native.rawFastValidate(this._fastSlot, input);
   }
 
   // Zero-copy pre-padded path
   isValidPrepadded(paddedBuffer, jsonLength) {
+    this._ensureNative();
     return native.rawFastValidate(this._fastSlot, paddedBuffer, jsonLength);
   }
 
   // Parallel NDJSON batch (multi-core)
   isValidParallel(buffer) {
+    this._ensureNative();
     return native.rawParallelValidate(this._fastSlot, buffer);
   }
 
-  // Parallel count (fastest — single uint32 return)
+  // Parallel count (fastest -- single uint32 return)
   countValid(buffer) {
+    this._ensureNative();
     return native.rawParallelCount(this._fastSlot, buffer);
   }
 
   // NDJSON single-thread batch
   isValidNDJSON(buffer) {
+    this._ensureNative();
     return native.rawNDJSONValidate(this._fastSlot, buffer);
   }
 }
@@ -492,44 +684,53 @@ function version() {
 //   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 => {
+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 ') + '})()';
+    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';
+  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) {
+Validator.bundleStandalone = function (schemas, opts) {
   const R = "Object.freeze({valid:true,errors:Object.freeze([])})";
-  const fns = schemas.map(schema => {
+  const fns = schemas.map((schema) => {
     const v = new Validator(schema, opts);
+    v._ensureCompiled();
     const jsFn = v._jsFn;
-    if (!jsFn || !jsFn._hybridSource) return 'null';
+    if (!jsFn || !jsFn._hybridSource) return "null";
     const jsErrFn = compileToJSCodegenWithErrors(
-      typeof schema === 'string' ? JSON.parse(schema) : schema
+      typeof schema === "string" ? JSON.parse(schema) : schema,
     );
-    const errBody = jsErrFn && jsErrFn._errSource
-      ? jsErrFn._errSource
-      : "return{valid:false,errors:[{code:'error',path:'',message:'validation failed'}]}";
+    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`;
+  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) {
+Validator.bundleCompact = function (schemas, opts) {
   // Analyze schemas and group by structure
-  const entries = schemas.map(schema => {
+  const entries = schemas.map((schema) => {
     const v = new Validator(schema, opts);
+    v._ensureCompiled();
     const jsFn = v._jsFn;
     if (!jsFn || !jsFn._hybridSource) return null;
     const jsErrFn = compileToJSCodegenWithErrors(
-      typeof schema === 'string' ? JSON.parse(schema) : schema
+      typeof schema === "string" ? JSON.parse(schema) : schema,
     );
     return {
       hybrid: jsFn._hybridSource,
@@ -543,14 +744,22 @@ Validator.bundleCompact = function(schemas, opts) {
   const errMap = new Map();
   const errBodies = [];
 
-  const indices = entries.map(e => {
+  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); }
+    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); }
+      if (ei === undefined) {
+        ei = errBodies.length;
+        errBodies.push(e.err);
+        errMap.set(e.err, ei);
+      }
     }
     return [hi, ei];
   });
@@ -561,31 +770,41 @@ Validator.bundleCompact = function(schemas, opts) {
 
   // Shared hybrid factories
   out += "var H=[\n";
-  out += bodies.map(b => `function(R,E){return function(d){${b}}}`).join(',\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 += 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 += 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) {
+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 };
+module.exports = {
+  Validator,
+  validate,
+  version,
+  createPaddedBuffer,
+  SIMDJSON_PADDING,
+};

package/package.json

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