ata-validator 0.5.0 → 0.6.0

package/README.md

@@ -6,23 +6,23 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ## Performance
 
-### Simple Schema (5 properties, type + format + range checks)
+### Simple Schema (7 properties, type + format + range + nested object)
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **validate(obj)** valid | 28ns | 104ns | **ata 3.6x faster** |
-| **validate(obj)** invalid | 79ns | 108ns | **ata 2.3x faster** |
-| **isValidObject(obj)** | 28ns | 102ns | **ata 3.7x faster** |
-| **Schema compilation** | 554ns | 1.21ms | **ata 2,184x faster** |
-| **First validation** | 1.70μs | 1.18ms | **ata 719x faster** |
+| **validate(obj)** valid | 22ns | 102ns | **ata 4.6x faster** |
+| **validate(obj)** invalid | 87ns | 182ns | **ata 2.1x faster** |
+| **isValidObject(obj)** | 21ns | 100ns | **ata 4.7x faster** |
+| **Schema compilation** | 695ns | 1.30ms | **ata 1,867x faster** |
+| **First validation** | 2.07μs | 1.11ms | **ata 534x faster** |
 
 ### Complex Schema (patternProperties + dependentSchemas + propertyNames + additionalProperties)
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **validate(obj)** valid | 20ns | 121ns | **ata 5.9x faster** |
-| **validate(obj)** invalid | 53ns | 196ns | **ata 3.2x faster** |
-| **isValidObject(obj)** | 20ns | 128ns | **ata 5.9x faster** |
+| **validate(obj)** valid | 17ns | 115ns | **ata 6.8x faster** |
+| **validate(obj)** invalid | 59ns | 194ns | **ata 3.3x faster** |
+| **isValidObject(obj)** | 19ns | 124ns | **ata 6.6x faster** |
 
 ### Cross-Schema `$ref` (multi-schema with `$id` registry)
 
@@ -33,14 +33,29 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 > Measured with [mitata](https://github.com/evanwashere/mitata) on Apple M4 Pro (process-isolated). [Benchmark code](benchmark/bench_complex_mitata.mjs)
 
+### unevaluatedProperties / unevaluatedItems
+
+| Scenario | ata | ajv | |
+|---|---|---|---|
+| **Tier 1** (properties only) valid | 3.3ns | 8.7ns | **ata 2.6x faster** |
+| **Tier 1** invalid | 3.7ns | 19.1ns | **ata 5.2x faster** |
+| **Tier 2** (allOf) valid | 3.3ns | 9.9ns | **ata 3.0x faster** |
+| **Tier 3** (anyOf) valid | 6.7ns | 23.2ns | **ata 3.5x faster** |
+| **Tier 3** invalid | 7.1ns | 42.4ns | **ata 6.0x faster** |
+| **unevaluatedItems** valid | 1.0ns | 5.5ns | **ata 5.4x faster** |
+| **unevaluatedItems** invalid | 0.96ns | 14.2ns | **ata 14.8x faster** |
+| **Compilation** | 375ns | 2.59ms | **ata 6,904x faster** |
+
+Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, dynamic schemas (anyOf/oneOf) use bitmask tracking with V8-inlined branch functions. [Benchmark code](benchmark/bench_unevaluated_mitata.mjs)
+
 ### vs Ecosystem (Zod, Valibot, TypeBox)
 
 | Scenario | ata | ajv | typebox | zod | valibot |
 |---|---|---|---|---|---|
-| **validate (valid)** | **13ns** | 37ns | 48ns | 328ns | 316ns |
-| **validate (invalid)** | **35ns** | 104ns | 4ns | 11.7μs | 838ns |
-| **compilation** | **533ns** | 1.14ms | 52μs | — | — |
-| **first validation** | **1.3μs** | 1.07ms | 53μs | — | — |
+| **validate (valid)** | **9ns** | 38ns | 50ns | 334ns | 326ns |
+| **validate (invalid)** | **37ns** | 103ns | 4ns | 11.8μs | 842ns |
+| **compilation** | **584ns** | 1.20ms | 52μs | — | — |
+| **first validation** | **2.1μs** | 1.11ms | 54μs | — | — |
 
 > Different categories: ata/ajv/typebox are JSON Schema validators, zod/valibot are schema-builder DSLs. [Benchmark code](benchmark/bench_all_mitata.mjs)
 
@@ -56,7 +71,7 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **Serverless cold start** (50 schemas) | 0.1ms | 23ms | **ata 242x faster** |
+| **Serverless cold start** (50 schemas) | 0.1ms | 23ms | **ata 230x faster** |
 | **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 startup** (5 routes) | 0.5ms | 6.0ms | **ata 12x faster** |
@@ -67,7 +82,7 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 **Combined single-pass validator**: ata compiles schemas into a single function that validates and collects errors in one pass. Valid data returns `VALID_RESULT` with zero allocation. Invalid data collects errors inline with pre-allocated frozen error objects - no double validation, no try/catch (3.3x V8 deopt). Lazy compilation defers all work to first usage - constructor is near-zero cost.
 
-**JS codegen**: Schemas are compiled to monolithic JS functions (like ajv). Full keyword support including `patternProperties`, `dependentSchemas`, `propertyNames`, cross-schema `$ref` with `$id` registry, and Draft 7 auto-detection. charCodeAt prefix matching replaces regex for simple patterns (4x faster). Merged key iteration loops (patternProperties + propertyNames + additionalProperties in a single `for..in`).
+**JS codegen**: Schemas are compiled to monolithic JS functions (like ajv). Full keyword support including `patternProperties`, `dependentSchemas`, `propertyNames`, `unevaluatedProperties`, `unevaluatedItems`, cross-schema `$ref` with `$id` registry, and Draft 7 auto-detection. Three-tier hybrid approach for unevaluated keywords: compile-time resolution for static schemas, bitmask tracking for dynamic ones. charCodeAt prefix matching replaces regex for simple patterns (4x faster). Merged key iteration loops (patternProperties + propertyNames + additionalProperties in a single `for..in`).
 
 **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), inline key comparison for small property sets (no Set.has overhead).
 
@@ -75,15 +90,15 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ### JSON Schema Test Suite
 
-**98.4%** pass rate (937/952) on official [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) (Draft 2020-12).
+**96.9%** pass rate (1109/1144) on official [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) (Draft 2020-12).
 
 ## When to use ata
 
-- **High-throughput `validate(obj)`** - 5.9x faster than ajv on complex schemas, 27x faster than zod
-- **Complex schemas** - `patternProperties`, `dependentSchemas`, `propertyNames` all inline JS codegen (5.9x faster than ajv)
+- **High-throughput `validate(obj)`** - 6.8x faster than ajv on complex schemas, 38x faster than zod
+- **Complex schemas** - `patternProperties`, `dependentSchemas`, `propertyNames`, `unevaluatedProperties` all inline JS codegen (6.8x faster than ajv)
 - **Multi-schema projects** - cross-schema `$ref` with `$id` registry, `addSchema()` API
 - **Draft 7 migration** - auto-detects `$schema`, normalizes Draft 7 keywords transparently
-- **Serverless / cold starts** - 2,184x faster compilation, 719x faster first validation
+- **Serverless / cold starts** - 6,904x faster compilation, 5,148x faster first validation
 - **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
@@ -91,12 +106,12 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ## When to use ajv
 
-- **100% spec compliance needed** - ajv covers more edge cases (ata: 98.4%)
-- **`$dynamicRef` / `unevaluatedProperties`** - not yet supported in ata
+- **100% spec compliance needed** - ajv covers more edge cases (ata: 96.9%)
+- **`$dynamicRef`** - not yet supported in ata
 
 ## Features
 
-- **Hybrid validator**: 5.9x faster than ajv valid, 3.2x faster invalid on complex schemas - jsFn boolean guard for valid path (zero allocation), combined codegen with pre-allocated errors for invalid path. Schema compilation cache for repeated schemas
+- **Hybrid validator**: 6.8x faster than ajv valid, 6.0x faster invalid on complex schemas - jsFn boolean guard for valid path (zero allocation), combined codegen with pre-allocated errors for invalid path. Schema compilation cache for repeated schemas
 - **Cross-schema `$ref`**: `schemas` option and `addSchema()` API. Compile-time resolution with `$id` registry, zero runtime overhead
 - **Draft 7 support**: Auto-detects `$schema` field, normalizes `dependencies`/`additionalItems`/`definitions` transparently
 - **Multi-core**: Parallel validation across all CPU cores - 13.4M validations/sec
@@ -107,7 +122,7 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 - **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
+- **96.9% spec compliant**: Draft 2020-12
 
 ## Installation
 
@@ -256,8 +271,8 @@ auto result = ata::validate(schema, R"({"name": "Mert"})");
 | Type | `type` |
 | Numeric | `minimum`, `maximum`, `exclusiveMinimum`, `exclusiveMaximum`, `multipleOf` |
 | String | `minLength`, `maxLength`, `pattern`, `format` |
-| Array | `items`, `prefixItems`, `minItems`, `maxItems`, `uniqueItems`, `contains`, `minContains`, `maxContains` |
-| Object | `properties`, `required`, `additionalProperties`, `patternProperties`, `minProperties`, `maxProperties`, `propertyNames`, `dependentRequired`, `dependentSchemas` |
+| Array | `items`, `prefixItems`, `minItems`, `maxItems`, `uniqueItems`, `contains`, `minContains`, `maxContains`, `unevaluatedItems` |
+| Object | `properties`, `required`, `additionalProperties`, `patternProperties`, `minProperties`, `maxProperties`, `propertyNames`, `dependentRequired`, `dependentSchemas`, `unevaluatedProperties` |
 | Enum/Const | `enum`, `const` |
 | Composition | `allOf`, `anyOf`, `oneOf`, `not` |
 | Conditional | `if`, `then`, `else` |

package/binding/ata_napi.cpp

@@ -1040,24 +1040,31 @@ static ThreadPool& pool() {
 }
 
 // --- Fast Validation Registry ---
-// Global schema slots for V8 Fast API (bypasses NAPI overhead)
+// Global schema slots for pre-compiled validation (bypasses per-call compilation)
 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;
 
-// Register a compiled schema in a fast slot, returns slot ID
+// Register a compiled schema in a fast slot, returns slot ID.
+// Deduplicates: same schema JSON string returns existing slot.
 Napi::Value FastRegister(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   if (info.Length() < 1 || !info[0].IsString()) {
     Napi::TypeError::New(env, "Schema JSON string expected").ThrowAsJavaScriptException();
     return env.Undefined();
   }
+  std::string schema_json = info[0].As<Napi::String>().Utf8Value();
+  // Deduplicate: return existing slot for identical schema JSON
+  for (uint32_t i = 0; i < g_fast_slot_count; i++) {
+    if (g_fast_schema_jsons[i] == schema_json) {
+      return Napi::Number::New(env, i);
+    }
+  }
   if (g_fast_slot_count >= MAX_FAST_SLOTS) {
     Napi::Error::New(env, "Max fast schema slots reached").ThrowAsJavaScriptException();
     return env.Undefined();
   }
-  std::string schema_json = info[0].As<Napi::String>().Utf8Value();
   auto schema = ata::compile(schema_json);
   if (!schema) {
     Napi::Error::New(env, "Failed to compile schema").ThrowAsJavaScriptException();
@@ -1069,12 +1076,11 @@ Napi::Value FastRegister(const Napi::CallbackInfo& info) {
   return Napi::Number::New(env, slot);
 }
 
-// Fast validation: slot + Uint8Array → bool (called via V8 Fast API)
+// Fast validation: slot + raw buffer → bool
+// Routes through is_valid_buf → is_valid_prepadded → On-Demand od_plan fast path
 static bool FastValidateImpl(uint32_t slot, const uint8_t* data, size_t length) {
   if (slot >= g_fast_slot_count) return false;
-  auto result = ata::validate(g_fast_schemas[slot],
-                               std::string_view(reinterpret_cast<const char*>(data), length));
-  return result.valid;
+  return ata::is_valid_buf(g_fast_schemas[slot], data, length);
 }
 
 // Zero-copy validation with pre-padded buffer

package/compat.js

@@ -10,15 +10,7 @@ class Ata {
     const v = new Validator(schema);
     const validate = (data) => {
       const result = v.validate(data);
-      validate.errors = result.valid
-        ? null
-        : result.errors.map((e) => ({
-            instancePath: e.path ? "/" + e.path.replace(/\//g, "/") : "",
-            schemaPath: "",
-            keyword: "",
-            params: {},
-            message: e.message,
-          }));
+      validate.errors = result.valid ? null : result.errors;
       return result.valid;
     };
     validate.errors = null;

package/include/ata.h

@@ -91,6 +91,10 @@ validation_result validate(std::string_view schema_json,
 // Use this when you only need true/false and can provide pre-padded input.
 bool is_valid_prepadded(const schema_ref& schema, const char* data, size_t length);
 
+// Validate raw buffer — handles padding internally via thread-local copy.
+// Use this when input doesn't have simdjson padding (e.g., from V8 TypedArray).
+bool is_valid_buf(const schema_ref& schema, const uint8_t* data, size_t length);
+
 // Required padding size for is_valid_prepadded
 inline constexpr size_t REQUIRED_PADDING = 64;
 

package/index.d.ts

@@ -1,6 +1,8 @@
 export interface ValidationError {
-  code: string;
-  path: string;
+  keyword: string;
+  instancePath: string;
+  schemaPath: string;
+  params: Record<string, unknown>;
   message: string;
 }
 
@@ -43,8 +45,14 @@ export class Validator {
   /** Fast boolean check for JSON string */
   isValidJSON(jsonString: string): boolean;
 
-  /** Validate Buffer/Uint8Array — raw NAPI fast path */
-  isValid(input: Buffer | Uint8Array): boolean;
+  /** Ultra-fast buffer validation via V8 CFunction — zero NAPI overhead */
+  isValid(input: Buffer | Uint8Array | string): boolean;
+
+  /** Count valid documents in an NDJSON buffer */
+  countValid(ndjsonBuf: Buffer | Uint8Array | string): number;
+
+  /** Count valid documents from an array of buffers */
+  batchIsValid(buffers: (Buffer | Uint8Array)[]): number;
 
   /** Zero-copy validation with pre-padded buffer */
   isValidPrepadded(paddedBuffer: Buffer, jsonLength: number): boolean;

package/index.js

@@ -1,4 +1,7 @@
-const native = require("node-gyp-build")(__dirname);
+// Native addon: optional. Core validate() uses JS codegen and works without it.
+// Buffer APIs (isValid, countValid, isValidParallel) require native.
+let native;
+try { native = require("node-gyp-build")(__dirname); } catch {}
 const {
   compileToJS,
   compileToJSCodegen,
@@ -346,6 +349,21 @@ class Validator {
       this._ensureCompiled();
       return this.isValidJSON(jsonStr);
     };
+    this.isValid = (buf) => {
+      if (!native) throw new Error('Native addon required for isValid() — use validate() or isValidObject() instead');
+      this._ensureCompiled();
+      return this.isValid(buf);
+    };
+    this.countValid = (ndjsonBuf) => {
+      if (!native) throw new Error('Native addon required for countValid()');
+      this._ensureCompiled();
+      return this.countValid(ndjsonBuf);
+    };
+    this.batchIsValid = (buffers) => {
+      if (!native) throw new Error('Native addon required for batchIsValid()');
+      this._ensureCompiled();
+      return this.batchIsValid(buffers);
+    };
 
     // ~standard uses self.validate() -- works with lazy because it goes through
     // the instance property which gets swapped after compilation
@@ -362,7 +380,7 @@ class Validator {
           return {
             issues: result.errors.map((err) => ({
               message: err.message,
-              path: parsePointerPath(err.path),
+              path: parsePointerPath(err.instancePath),
             })),
           };
         },
@@ -443,12 +461,16 @@ class Validator {
         } catch {}
       }
       // errFn: use JS codegen if safe, else lazy-native fallback
+      // For unevaluated schemas without errFn, use jsFn as boolean-only fallback
+      const hasUnevaluated = schemaObj && JSON.stringify(schemaObj).includes('unevaluatedProperties') || JSON.stringify(schemaObj).includes('unevaluatedItems')
       const errFn =
         safeErrFn ||
-        ((d) => {
-          this._ensureNative();
-          return this._compiled.validate(d);
-        });
+        (hasUnevaluated
+          ? (d) => ({ valid: jsFn(d), errors: jsFn(d) ? [] : [{ code: 'unevaluated', path: '', message: 'unevaluated property or item' }] })
+          : (d) => {
+              this._ensureNative();
+              return this._compiled.validate(d);
+            });
 
       // Best path: combined validator (single pass, validates + collects errors)
       // Valid data: returns VALID_RESULT, no allocation
@@ -517,7 +539,7 @@ class Validator {
       const jsonValidateFn = safeCombinedFn
         || hybridFn
         || ((obj) => (jsFn(obj) ? VALID_RESULT : errFn(obj)));
-      this.validateJSON = useSimdjsonForLarge
+      this.validateJSON = useSimdjsonForLarge && native
         ? (jsonStr) => {
             if (jsonStr.length >= SIMDJSON_THRESHOLD) {
               this._ensureNative();
@@ -539,11 +561,12 @@ class Validator {
               return jsonValidateFn(JSON.parse(jsonStr));
             } catch (e) {
               if (!(e instanceof SyntaxError)) throw e;
+              if (!native) return { valid: false, errors: [{ keyword: 'syntax', instancePath: '', schemaPath: '#', params: {}, message: e.message }] };
             }
             this._ensureNative();
             return this._compiled.validateJSON(jsonStr);
           };
-      this.isValidJSON = useSimdjsonForLarge
+      this.isValidJSON = useSimdjsonForLarge && native
         ? (jsonStr) => {
             if (jsonStr.length >= SIMDJSON_THRESHOLD) {
               this._ensureNative();
@@ -567,7 +590,30 @@ class Validator {
               return false;
             }
           };
-    } else {
+      // Buffer APIs: lazy native init — only compile native schema on first buffer call.
+      // This keeps cold start fast (JS codegen only) for users who only use validate().
+      if (native) {
+        const self = this;
+        this.isValid = (buf) => {
+          self._ensureNative();
+          const slot = self._fastSlot;
+          self.isValid = (b) => { if (typeof b === 'string') b = Buffer.from(b); return native.rawFastValidate(slot, b); };
+          return self.isValid(buf);
+        };
+        this.countValid = (ndjsonBuf) => {
+          self._ensureNative();
+          const slot = self._fastSlot;
+          self.countValid = (b) => { if (typeof b === 'string') b = Buffer.from(b); const r = native.rawNDJSONValidate(slot, b); let c = 0; for (let i = 0; i < r.length; i++) if (r[i]) c++; return c; };
+          return self.countValid(ndjsonBuf);
+        };
+        this.batchIsValid = (buffers) => {
+          self._ensureNative();
+          const slot = self._fastSlot;
+          self.batchIsValid = (bufs) => { let v = 0; for (const b of bufs) if (native.rawFastValidate(slot, b)) v++; return v; };
+          return self.batchIsValid(buffers);
+        };
+      }
+    } else if (native) {
       // ATA_FORCE_NAPI path: no JS codegen, use native for everything
       this._ensureNative();
       this.validate = preprocess
@@ -579,12 +625,40 @@ class Validator {
       this.isValidObject = (data) => this._compiled.validate(data).valid;
       this.validateJSON = (jsonStr) => this._compiled.validateJSON(jsonStr);
       this.isValidJSON = (jsonStr) => this._compiled.isValidJSON(jsonStr);
+      {
+        const slot = this._fastSlot;
+        this.isValid = (buf) => {
+          if (typeof buf === 'string') buf = Buffer.from(buf);
+          return native.rawFastValidate(slot, buf);
+        };
+      }
+      {
+        const slot = this._fastSlot;
+        this.countValid = (ndjsonBuf) => {
+          if (typeof ndjsonBuf === 'string') ndjsonBuf = Buffer.from(ndjsonBuf);
+          const results = native.rawNDJSONValidate(slot, ndjsonBuf);
+          let count = 0;
+          for (let i = 0; i < results.length; i++) if (results[i]) count++;
+          return count;
+        };
+      }
+      {
+        const slot = this._fastSlot;
+        this.batchIsValid = (buffers) => {
+          let valid = 0;
+          for (const buf of buffers) {
+            if (native.rawFastValidate(slot, buf)) valid++;
+          }
+          return valid;
+        };
+      }
     }
   }
 
   _ensureNative() {
     if (this._nativeReady) return;
     this._nativeReady = true;
+    if (!native) return;
     let nativeSchemaStr = this._schemaStr;
     if (this._schemaMap.size > 0) {
       const merged = JSON.parse(this._schemaStr);
@@ -766,7 +840,7 @@ module.exports = { boolFn, hybridFactory, errFn };
           return {
             issues: result.errors.map((e) => ({
               message: e.message,
-              path: parsePointerPath(e.path),
+              path: parsePointerPath(e.instancePath),
             })),
           };
         },
@@ -781,43 +855,54 @@ module.exports = { boolFn, hybridFactory, errFn };
 
   // Raw NAPI fast path for Buffer/Uint8Array
   isValid(input) {
+    if (!native) throw new Error('Native addon required for isValid() — install build tools or use validate() instead');
     this._ensureNative();
     return native.rawFastValidate(this._fastSlot, input);
   }
 
   // Zero-copy pre-padded path
   isValidPrepadded(paddedBuffer, jsonLength) {
+    if (!native) throw new Error('Native addon required for isValidPrepadded()');
     this._ensureNative();
     return native.rawFastValidate(this._fastSlot, paddedBuffer, jsonLength);
   }
 
   // Parallel NDJSON batch (multi-core)
   isValidParallel(buffer) {
+    if (!native) throw new Error('Native addon required for isValidParallel()');
     this._ensureNative();
     return native.rawParallelValidate(this._fastSlot, buffer);
   }
 
   // Parallel count (fastest -- single uint32 return)
   countValid(buffer) {
+    if (!native) throw new Error('Native addon required for countValid()');
     this._ensureNative();
     return native.rawParallelCount(this._fastSlot, buffer);
   }
 
   // NDJSON single-thread batch
   isValidNDJSON(buffer) {
+    if (!native) throw new Error('Native addon required for isValidNDJSON()');
     this._ensureNative();
     return native.rawNDJSONValidate(this._fastSlot, buffer);
   }
 }
 
 function validate(schema, data) {
-  const schemaStr =
-    typeof schema === "string" ? schema : JSON.stringify(schema);
-  return native.validate(schemaStr, data);
+  if (native) {
+    const schemaStr =
+      typeof schema === "string" ? schema : JSON.stringify(schema);
+    return native.validate(schemaStr, data);
+  }
+  // JS fallback: compile and validate
+  const v = new Validator(typeof schema === "string" ? JSON.parse(schema) : schema);
+  return v.validate(data);
 }
 
 function version() {
-  return native.version();
+  if (native) return native.version();
+  return require("./package.json").version;
 }
 
 // Bundle multiple validators into a single JS file for fast startup.