ata-validator 0.4.9 → 0.4.11

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/binding/ata_napi.cpp

@@ -28,7 +28,7 @@ using schema_node_ptr = std::shared_ptr<schema_node>;
 
 // MUST match layout in src/ata.cpp exactly (reinterpret_cast)
 struct schema_node {
-  std::vector<std::string> types;
+  uint8_t type_mask = 0;
 
   std::optional<double> minimum;
   std::optional<double> maximum;
@@ -67,11 +67,11 @@ struct schema_node {
   };
   std::vector<pattern_prop> pattern_properties;
 
-  std::optional<std::string> enum_values_raw;
   std::vector<std::string> enum_values_minified;
   std::optional<std::string> const_value_raw;
 
   std::optional<std::string> format;
+  uint8_t format_id = 255;
 
   std::vector<schema_node_ptr> all_of;
   std::vector<schema_node_ptr> any_of;
@@ -413,46 +413,39 @@ static void validate_napi(const schema_node_ptr& node,
 
   auto actual_type = napi_type_of(value);
 
-  // type
-  if (!node->types.empty()) {
-    bool match = false;
-    for (const auto& t : node->types) {
-      if (napi_type_matches(value, t)) {
-        match = true;
-        break;
-      }
-    }
-    if (!match) {
+  // type — uses bitmask matching ata.cpp json_type enum order:
+  //   0=string, 1=number, 2=integer, 3=boolean, 4=null_value, 5=object, 6=array
+  if (node->type_mask) {
+    uint8_t val_bits = 0;
+    if (actual_type == "string")       val_bits = 1u << 0;
+    else if (actual_type == "number")  val_bits = 1u << 1;
+    else if (actual_type == "integer") val_bits = (1u << 2) | (1u << 1); // integer matches number
+    else if (actual_type == "boolean") val_bits = 1u << 3;
+    else if (actual_type == "null")    val_bits = 1u << 4;
+    else if (actual_type == "object")  val_bits = 1u << 5;
+    else if (actual_type == "array")   val_bits = 1u << 6;
+    if (!(val_bits & node->type_mask)) {
+      static const char* type_names[] = {"string","number","integer","boolean","null","object","array"};
       std::string expected;
-      for (size_t i = 0; i < node->types.size(); ++i) {
-        if (i > 0) expected += ", ";
-        expected += node->types[i];
+      for (int b = 0; b < 7; ++b) {
+        if (node->type_mask & (1u << b)) {
+          if (!expected.empty()) expected += ", ";
+          expected += type_names[b];
+        }
       }
       errors.push_back({ata::error_code::type_mismatch, path,
                         "expected type " + expected + ", got " + actual_type});
     }
   }
 
-  // enum
-  if (node->enum_values_raw.has_value()) {
+  // enum — compare against pre-minified canonical values
+  if (!node->enum_values_minified.empty()) {
     std::string val_json = napi_to_json(env, value);
-    // Parse enum from raw and compare
     bool found = false;
-    // We need to compare against each element in the enum array
-    // The enum_values_raw is a JSON array string like [1,2,3]
-    // We'll use JSON.parse in JS to handle this
-    auto json_obj = env.Global().Get("JSON").As<Napi::Object>();
-    auto parse_fn = json_obj.Get("parse").As<Napi::Function>();
-    auto enum_arr = parse_fn.Call(json_obj,
-        {Napi::String::New(env, node->enum_values_raw.value())});
-    if (enum_arr.IsArray()) {
-      auto arr = enum_arr.As<Napi::Array>();
-      for (uint32_t i = 0; i < arr.Length(); ++i) {
-        std::string elem_json = napi_to_json(env, arr.Get(i));
-        if (elem_json == val_json) {
-          found = true;
-          break;
-        }
+    for (const auto& ev : node->enum_values_minified) {
+      if (ev == val_json) {
+        found = true;
+        break;
       }
     }
     if (!found) {