ata-validator 0.10.0 → 0.10.1

package/README.md

@@ -102,7 +102,7 @@ Self-recursive named functions for $dynamicRef, compile-time cross-schema resolu
 
 ### JSON Schema Test Suite
 
-**95.3%** pass rate (1170/1227) on official [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) (Draft 2020-12). **95.3%** on [@exodus/schemasafe](https://github.com/ExodusMovement/schemasafe) test suite.
+**98.5%** pass rate (1172/1190) on official [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) (Draft 2020-12), excluding remote refs and vocabulary (intentionally unsupported). **95.3%** on [@exodus/schemasafe](https://github.com/ExodusMovement/schemasafe) test suite.
 
 ## When to use ata
 
@@ -135,7 +135,7 @@ Self-recursive named functions for $dynamicRef, compile-time cross-schema resolu
 - **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
-- **96.9% spec compliant**: Draft 2020-12
+- **98.5% spec compliant**: Draft 2020-12
 
 ## Installation
 

package/binding/ata_napi.cpp

@@ -17,7 +17,6 @@
 #include <vector>
 
 #include "ata.h"
-#include <simdjson.h>
 
 // ============================================================================
 // V8 Direct Object Traversal Engine
@@ -798,67 +797,6 @@ static void validate_napi(const schema_node_ptr& node,
 // N-API Binding
 // ============================================================================
 
-// ============================================================================
-// simdjson DOM to V8 JS Object conversion
-// ============================================================================
-
-static Napi::Value dom_to_napi(Napi::Env env, simdjson::dom::element el) {
-  using namespace simdjson;
-  switch (el.type()) {
-    case dom::element_type::OBJECT: {
-      auto obj = Napi::Object::New(env);
-      for (auto [key, val] : dom::object(el)) {
-        obj.Set(std::string(key), dom_to_napi(env, val));
-      }
-      return obj;
-    }
-    case dom::element_type::ARRAY: {
-      dom::array arr = el;
-      auto jsArr = Napi::Array::New(env, arr.size());
-      uint32_t i = 0;
-      for (auto val : arr) {
-        jsArr.Set(i++, dom_to_napi(env, val));
-      }
-      return jsArr;
-    }
-    case dom::element_type::STRING: {
-      std::string_view sv;
-      el.get(sv);
-      return Napi::String::New(env, sv.data(), sv.length());
-    }
-    case dom::element_type::INT64: {
-      int64_t v;
-      el.get(v);
-      return Napi::Number::New(env, static_cast<double>(v));
-    }
-    case dom::element_type::UINT64: {
-      uint64_t v;
-      el.get(v);
-      return Napi::Number::New(env, static_cast<double>(v));
-    }
-    case dom::element_type::DOUBLE: {
-      double v;
-      el.get(v);
-      return Napi::Number::New(env, v);
-    }
-    case dom::element_type::BOOL: {
-      bool v;
-      el.get(v);
-      return Napi::Boolean::New(env, v);
-    }
-    case dom::element_type::NULL_VALUE:
-      return env.Null();
-    default:
-      return env.Undefined();
-  }
-}
-
-// Thread-local simdjson DOM parser for parseJSON / validateAndParse
-static simdjson::dom::parser& tl_dom_parser() {
-  thread_local simdjson::dom::parser parser;
-  return parser;
-}
-
 static Napi::Object make_result(Napi::Env env,
                                 const ata::validation_result& result) {
   Napi::Object obj = Napi::Object::New(env);
@@ -884,8 +822,7 @@ class CompiledSchema : public Napi::ObjectWrap<CompiledSchema> {
         {InstanceMethod("validate", &CompiledSchema::Validate),
          InstanceMethod("validateJSON", &CompiledSchema::ValidateJSON),
          InstanceMethod("validateDirect", &CompiledSchema::ValidateDirect),
-         InstanceMethod("isValidJSON", &CompiledSchema::IsValidJSON),
-         InstanceMethod("validateAndParse", &CompiledSchema::ValidateAndParse)});
+         InstanceMethod("isValidJSON", &CompiledSchema::IsValidJSON)});
     auto* constructor = new Napi::FunctionReference();
     *constructor = Napi::Persistent(func);
     env.SetInstanceData(constructor);
@@ -1007,77 +944,6 @@ class CompiledSchema : public Napi::ObjectWrap<CompiledSchema> {
     return ValidateDirectImpl(env, info[0]);
   }
 
-  // Parse JSON with simdjson, validate against schema, return parsed JS object
-  Napi::Value ValidateAndParse(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    if (info.Length() < 1) {
-      Napi::TypeError::New(env, "JSON string or Buffer expected")
-          .ThrowAsJavaScriptException();
-      return env.Undefined();
-    }
-
-    const char* data;
-    size_t len;
-
-    if (info[0].IsBuffer()) {
-      auto buf = info[0].As<Napi::Buffer<char>>();
-      data = buf.Data();
-      len = buf.Length();
-    } else if (info[0].IsString()) {
-      auto [d, l] = extract_string(env, info[0]);
-      data = d;
-      len = l;
-    } else {
-      Napi::TypeError::New(env, "JSON string or Buffer expected")
-          .ThrowAsJavaScriptException();
-      return env.Undefined();
-    }
-
-    // Parse with simdjson
-    simdjson::padded_string padded(data, len);
-    auto& parser = tl_dom_parser();
-    auto doc_result = parser.parse(padded);
-    if (doc_result.error()) {
-      auto obj = Napi::Object::New(env);
-      obj.Set("valid", false);
-      obj.Set("value", env.Null());
-      auto errors = Napi::Array::New(env, 1);
-      auto err = Napi::Object::New(env);
-      err.Set("code", Napi::Number::New(env, static_cast<int>(ata::error_code::invalid_json)));
-      err.Set("path", Napi::String::New(env, ""));
-      err.Set("message", Napi::String::New(env, "Invalid JSON"));
-      errors[0u] = err;
-      obj.Set("errors", errors);
-      return obj;
-    }
-
-    // Validate
-    auto valResult = ata::validate(schema_, std::string_view(data, len));
-
-    // Convert DOM to JS object
-    Napi::Value jsValue = dom_to_napi(env, doc_result.value());
-
-    // Build result
-    auto obj = Napi::Object::New(env);
-    obj.Set("valid", valResult.valid);
-    obj.Set("value", jsValue);
-    if (valResult.valid) {
-      obj.Set("errors", Napi::Array::New(env, 0));
-    } else {
-      Napi::Array errors = Napi::Array::New(env, valResult.errors.size());
-      for (size_t i = 0; i < valResult.errors.size(); ++i) {
-        Napi::Object err = Napi::Object::New(env);
-        err.Set("code",
-                Napi::Number::New(env, static_cast<int>(valResult.errors[i].code)));
-        err.Set("path", Napi::String::New(env, valResult.errors[i].path));
-        err.Set("message", Napi::String::New(env, valResult.errors[i].message));
-        errors[i] = err;
-      }
-      obj.Set("errors", errors);
-    }
-    return obj;
-  }
-
  private:
   Napi::Value ValidateDirectImpl(Napi::Env env, Napi::Value value) {
     compiled_schema_internal ctx;
@@ -1130,44 +996,6 @@ Napi::Value GetVersion(const Napi::CallbackInfo& info) {
   return Napi::String::New(info.Env(), std::string(ata::version()));
 }
 
-// Standalone JSON parser using simdjson — returns parsed JS object
-Napi::Value ParseJSON(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  if (info.Length() < 1) {
-    Napi::TypeError::New(env, "JSON string or Buffer expected")
-        .ThrowAsJavaScriptException();
-    return env.Undefined();
-  }
-
-  const char* data;
-  size_t len;
-
-  if (info[0].IsBuffer()) {
-    auto buf = info[0].As<Napi::Buffer<char>>();
-    data = buf.Data();
-    len = buf.Length();
-  } else if (info[0].IsString()) {
-    auto [d, l] = CompiledSchema::extract_string(env, info[0]);
-    data = d;
-    len = l;
-  } else {
-    Napi::TypeError::New(env, "JSON string or Buffer expected")
-        .ThrowAsJavaScriptException();
-    return env.Undefined();
-  }
-
-  // Parse with simdjson using thread-local parser
-  simdjson::padded_string padded(data, len);
-  auto& parser = tl_dom_parser();
-  auto result = parser.parse(padded);
-  if (result.error()) {
-    Napi::Error::New(env, "Invalid JSON").ThrowAsJavaScriptException();
-    return env.Undefined();
-  }
-
-  return dom_to_napi(env, result.value());
-}
-
 // --- Thread Pool ---
 class ThreadPool {
 public:
@@ -1703,7 +1531,6 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   CompiledSchema::Init(env, exports);
   exports.Set("validate", Napi::Function::New(env, ValidateOneShot));
   exports.Set("version", Napi::Function::New(env, GetVersion));
-  exports.Set("parseJSON", Napi::Function::New(env, ParseJSON));
   exports.Set("fastRegister", Napi::Function::New(env, FastRegister));
   exports.Set("fastValidate", Napi::Function::New(env, FastValidateSlow));
 

package/index.d.ts

@@ -11,6 +11,12 @@ export interface ValidationResult {
   errors: ValidationError[];
 }
 
+export interface ValidateAndParseResult {
+  valid: boolean;
+  value: unknown;
+  errors: ValidationError[];
+}
+
 export interface ValidatorOptions {
   coerceTypes?: boolean;
   removeAdditional?: boolean;
@@ -27,56 +33,93 @@ export interface StandardSchemaV1Props {
     | { issues: Array<{ message: string; path?: ReadonlyArray<{ key: PropertyKey }> }> };
 }
 
+export interface StandaloneModule {
+  boolFn: (data: unknown) => boolean;
+  hybridFactory: (validResult: object, errFn: Function) => (data: unknown) => ValidationResult;
+  errFn: ((data: unknown, allErrors?: boolean) => ValidationResult) | null;
+}
+
 export class Validator {
   constructor(schema: object | string, options?: ValidatorOptions);
 
-  /** Add a schema to the validator */
+  /** Add a schema to the registry for cross-schema $ref resolution */
   addSchema(schema: object): void;
 
-  /** Validate data — returns result with errors. Applies defaults, coerceTypes, removeAdditional. */
+  /** Validate data, returns result with errors. Applies defaults, coerceTypes, removeAdditional. */
   validate(data: unknown): ValidationResult;
 
-  /** Fast boolean check — JS codegen, no error collection */
+  /** Fast boolean check via JS codegen or tier 0 interpreter. No error collection. */
   isValidObject(data: unknown): boolean;
 
-  /** Validate JSON string — simdjson fast path for large docs */
+  /** Validate a JSON string. Uses simdjson fast path for large documents. */
   validateJSON(jsonString: string): ValidationResult;
 
-  /** Fast boolean check for JSON string */
+  /** Fast boolean check for a JSON string */
   isValidJSON(jsonString: string): boolean;
 
-  /** Ultra-fast buffer validation via V8 CFunction — zero NAPI overhead */
+  /** Parse JSON with simdjson + validate against schema. Returns parsed value and validation result. Requires native addon. */
+  validateAndParse(jsonString: string | Buffer): ValidateAndParseResult;
+
+  /** Ultra-fast buffer validation via native addon */
   isValid(input: Buffer | Uint8Array | string): boolean;
 
-  /** Count valid documents in an NDJSON buffer */
+  /** Count valid documents in an NDJSON buffer. Requires native addon. */
   countValid(ndjsonBuf: Buffer | Uint8Array | string): number;
 
-  /** Count valid documents from an array of buffers */
+  /** Validate an array of buffers, returns count of valid ones. Requires native addon. */
   batchIsValid(buffers: (Buffer | Uint8Array)[]): number;
 
-  /** Zero-copy validation with pre-padded buffer */
+  /** Zero-copy validation with pre-padded buffer. Requires native addon. */
   isValidPrepadded(paddedBuffer: Buffer, jsonLength: number): boolean;
 
-  /** Multi-core parallel NDJSON validation — returns boolean per line */
+  /** Multi-core parallel NDJSON validation. Returns boolean per line. Requires native addon. */
   isValidParallel(ndjsonBuffer: Buffer): boolean[];
 
-  /** Multi-core parallel NDJSON count — returns number of valid items */
-  countValid(ndjsonBuffer: Buffer): number;
-
-  /** Single-thread NDJSON batch validation */
+  /** Single-thread NDJSON batch validation. Requires native addon. */
   isValidNDJSON(ndjsonBuffer: Buffer): boolean[];
 
-  /** Standard Schema V1 interface — compatible with Fastify, tRPC, TanStack, etc. */
+  /** Generate a standalone JS module string for zero-compile loading. Returns null if schema can't be standalone-compiled. */
+  toStandalone(): string | null;
+
+  /** Load a pre-compiled standalone module. Zero schema compilation at startup. */
+  static fromStandalone(mod: StandaloneModule, schema: object | string, options?: ValidatorOptions): Validator;
+
+  /** Bundle multiple schemas into a single JS module string. Load with Validator.loadBundle(). */
+  static bundle(schemas: object[], options?: ValidatorOptions): string;
+
+  /** Bundle multiple schemas into a self-contained JS module. No ata-validator import needed at runtime. */
+  static bundleStandalone(schemas: object[], options?: ValidatorOptions): string;
+
+  /** Bundle multiple schemas with deduplicated shared templates. Smaller output than bundle(). */
+  static bundleCompact(schemas: object[], options?: ValidatorOptions): string;
+
+  /** Load a bundle created by Validator.bundle(). Returns array of Validator instances. */
+  static loadBundle(mods: object[], schemas: object[], options?: ValidatorOptions): Validator[];
+
+  /** Standard Schema V1 interface, compatible with Fastify, tRPC, TanStack, etc. */
   readonly "~standard": StandardSchemaV1Props;
 }
 
+/** One-shot validate: creates a Validator, validates data, returns result. */
 export function validate(
   schema: object | string,
   data: unknown
 ): ValidationResult;
 
+/** Fast compile: returns a validate function directly. WeakMap cached, second call with same schema is near-zero cost. */
+export function compile(
+  schema: object | string,
+  options?: ValidatorOptions
+): (data: unknown) => ValidationResult;
+
+/** Parse JSON using simdjson (native addon) or JSON.parse (fallback). */
+export function parseJSON(jsonString: string | Buffer): unknown;
+
+/** Returns ata-validator version string. */
 export function version(): string;
 
+/** Create a simdjson-compatible padded buffer from a JSON string. */
 export function createPaddedBuffer(jsonStr: string): { buffer: Buffer; length: number };
 
+/** Required padding size for simdjson buffers. */
 export const SIMDJSON_PADDING: number;

package/lib/js-compiler.js

@@ -4,6 +4,10 @@
 // Closure-based validator — no new Function() or eval().
 // Returns null if the schema is too complex for JS compilation.
 
+// Count Unicode code points, not UTF-16 code units (surrogate pairs).
+// JSON Schema: minLength/maxLength count characters per RFC 8259.
+function _cpLen(s) { let n = 0; for (const _ of s) n++; return n; }
+
 // AJV-compatible error message templates (compile-time, not runtime)
 const AJV_MESSAGES = {
   type: (p) => `must be ${p.type}`,
@@ -271,11 +275,11 @@ function compileToJS(schema, defs, schemaMap) {
   // string
   if (schema.minLength !== undefined) {
     const min = schema.minLength
-    checks.push((d) => typeof d !== 'string' || d.length >= min)
+    checks.push((d) => typeof d !== 'string' || _cpLen(d) >= min)
   }
   if (schema.maxLength !== undefined) {
     const max = schema.maxLength
-    checks.push((d) => typeof d !== 'string' || d.length <= max)
+    checks.push((d) => typeof d !== 'string' || _cpLen(d) <= max)
   }
   if (schema.pattern) {
     try {
@@ -775,7 +779,7 @@ function compileToJSCodegen(schema, schemaMap) {
     }
   }
 
-  const ctx = { varCounter: 0, helpers: [], helperCode: [], closureVars: [], closureVals: [], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: schema }
+  const ctx = { varCounter: 0, helpers: [], helperCode: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: schema }
   const lines = []
   genCode(schema, 'd', lines, ctx)
 
@@ -914,8 +918,8 @@ function tryGenCombined(schema, access, ctx) {
 
   if (t === 'string') {
     const conds = [`typeof _v!=='string'`]
-    if (schema.minLength !== undefined) conds.push(`_v.length<${schema.minLength}`)
-    if (schema.maxLength !== undefined) conds.push(`_v.length>${schema.maxLength}`)
+    if (schema.minLength !== undefined) conds.push(`_cpLen(_v)<${schema.minLength}`)
+    if (schema.maxLength !== undefined) conds.push(`_cpLen(_v)>${schema.maxLength}`)
     if (conds.length < 2 && !schema.pattern && !schema.format) return null // not worth combining
     // pattern and format need separate statements, fall back if present
     if (schema.pattern || schema.format) return null
@@ -956,6 +960,9 @@ function tryGenCombined(schema, access, ctx) {
 // 'string' / 'number' / 'integer' = we know the primitive type
 function genCode(schema, v, lines, ctx, knownType) {
   if (typeof schema !== 'object' || schema === null) return
+  if (!ctx.regExpMap) {
+    ctx.regExpMap = new Map();
+  }
 
   // $ref — guard against circular references
   // In 2020-12 with unevaluated*, $ref can coexist with siblings — don't early return
@@ -1159,8 +1166,8 @@ function genCode(schema, v, lines, ctx, knownType) {
   if (schema.multipleOf !== undefined) lines.push(isNum ? `if(${v}%${schema.multipleOf}!==0)return false` : `if(typeof ${v}==='number'&&${v}%${schema.multipleOf}!==0)return false`)
 
   // string — skip type guard if known string
-  if (schema.minLength !== undefined) lines.push(isStr ? `if(${v}.length<${schema.minLength})return false` : `if(typeof ${v}==='string'&&${v}.length<${schema.minLength})return false`)
-  if (schema.maxLength !== undefined) lines.push(isStr ? `if(${v}.length>${schema.maxLength})return false` : `if(typeof ${v}==='string'&&${v}.length>${schema.maxLength})return false`)
+  if (schema.minLength !== undefined) lines.push(isStr ? `if(_cpLen(${v})<${schema.minLength})return false` : `if(typeof ${v}==='string'&&_cpLen(${v})<${schema.minLength})return false`)
+  if (schema.maxLength !== undefined) lines.push(isStr ? `if(_cpLen(${v})>${schema.maxLength})return false` : `if(typeof ${v}==='string'&&_cpLen(${v})>${schema.maxLength})return false`)
 
   // array size — skip guard if known array
   if (schema.minItems !== undefined) lines.push(isArr ? `if(${v}.length<${schema.minItems})return false` : `if(Array.isArray(${v})&&${v}.length<${schema.minItems})return false`)
@@ -1176,8 +1183,13 @@ function genCode(schema, v, lines, ctx, knownType) {
     if (inlineCheck) {
       lines.push(isStr ? `if(!(${inlineCheck}))return false` : `if(typeof ${v}==='string'&&!(${inlineCheck}))return false`)
     } else {
-      const ri = ctx.varCounter++
-      ctx.helperCode.push(`const _re${ri}=new RegExp(${JSON.stringify(schema.pattern)})`)
+      const pattern = JSON.stringify(schema.pattern);
+      if (!ctx.regExpMap.has(pattern)) {
+        const ri = ctx.varCounter++
+        ctx.regExpMap.set(pattern, ri)
+        ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`);
+      }
+      const ri = ctx.regExpMap.get(pattern);
       lines.push(isStr ? `if(!_re${ri}.test(${v}))return false` : `if(typeof ${v}==='string'&&!_re${ri}.test(${v}))return false`)
     }
   }
@@ -2264,6 +2276,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap) {
   }
 
   const ctx = { varCounter: 0, helperCode: [], rootDefs: eRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: eAnchors, rootSchema: schema }
+  ctx.helperCode.push('const _cpLen=s=>{let n=0;for(const _ of s)n++;return n}')
   const lines = []
   genCodeE(schema, 'd', '', lines, ctx, '#')
   if (lines.length === 0) return (d) => ({ valid: true, errors: [] })
@@ -2296,7 +2309,9 @@ function compileToJSCodegenWithErrors(schema, schemaMap) {
 function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (!schemaPrefix) schemaPrefix = '#'
   if (typeof schema !== 'object' || schema === null) return
-
+  if (!ctx.regExpMap) {
+    ctx.regExpMap = new Map();
+  }
   // $ref — resolve local and cross-schema refs
   if (schema.$ref) {
     // Self-reference "#" — no-op (permissive) to avoid infinite recursion
@@ -2440,11 +2455,11 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 
   // string
   if (schema.minLength !== undefined) {
-    const c = isStr ? `${v}.length<${schema.minLength}` : `typeof ${v}==='string'&&${v}.length<${schema.minLength}`
+    const c = isStr ? `_cpLen(${v})<${schema.minLength}` : `typeof ${v}==='string'&&_cpLen(${v})<${schema.minLength}`
     lines.push(`if(${c}){${fail('minLength', 'minLength', `{limit:${schema.minLength}}`, `'must NOT have fewer than ${schema.minLength} characters'`)}}`)
   }
   if (schema.maxLength !== undefined) {
-    const c = isStr ? `${v}.length>${schema.maxLength}` : `typeof ${v}==='string'&&${v}.length>${schema.maxLength}`
+    const c = isStr ? `_cpLen(${v})>${schema.maxLength}` : `typeof ${v}==='string'&&_cpLen(${v})>${schema.maxLength}`
     lines.push(`if(${c}){${fail('maxLength', 'maxLength', `{limit:${schema.maxLength}}`, `'must NOT have more than ${schema.maxLength} characters'`)}}`)
   }
   if (schema.pattern) {
@@ -2453,8 +2468,13 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       const c = isStr ? `!(${inlineCheck})` : `typeof ${v}==='string'&&!(${inlineCheck})`
       lines.push(`if(${c}){${fail('pattern', 'pattern', `{pattern:${JSON.stringify(schema.pattern)}}`, `'must match pattern "${schema.pattern}"'`)}}`)
     } else {
-      const ri = ctx.varCounter++
-      ctx.helperCode.push(`const _re${ri}=new RegExp(${JSON.stringify(schema.pattern)})`)
+      const pattern = JSON.stringify(schema.pattern);
+      if (!ctx.regExpMap.has(pattern)) {
+        const ri = ctx.varCounter++
+        ctx.regExpMap.set(pattern, ri)
+        ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`)
+      }
+      const ri = ctx.regExpMap.get(pattern);
       const c = isStr ? `!_re${ri}.test(${v})` : `typeof ${v}==='string'&&!_re${ri}.test(${v})`
       lines.push(`if(${c}){${fail('pattern', 'pattern', `{pattern:${JSON.stringify(schema.pattern)}}`, `'must match pattern "${schema.pattern}"'`)}}`)
     }
@@ -2539,8 +2559,13 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // patternProperties
   if (schema.patternProperties) {
     for (const [pat, sub] of Object.entries(schema.patternProperties)) {
-      const ri = ctx.varCounter++
-      ctx.helperCode.push(`const _re${ri}=new RegExp(${JSON.stringify(pat)})`)
+      const pattern = JSON.stringify(pat);
+      if (!ctx.regExpMap.has(pattern)) {
+        const ri = ctx.varCounter++
+        ctx.regExpMap.set(pattern, ri)
+        ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`);
+      }
+      const ri = ctx.regExpMap.get(pattern);
       const ki = ctx.varCounter++
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){if(_re${ri}.test(_k${ki})){`)
       const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
@@ -2570,8 +2595,13 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       lines.push(`if(_k${ki}.length>${pn.maxLength}){${fail('maxLength', 'propertyNames/maxLength', `{limit:${pn.maxLength}}`, `'must NOT have more than ${pn.maxLength} characters'`)}}`)
     }
     if (pn.pattern) {
-      const ri = ctx.varCounter++
-      ctx.helperCode.push(`const _re${ri}=new RegExp(${JSON.stringify(pn.pattern)})`)
+      const pattern = JSON.stringify(pn.pattern);
+      if (!ctx.regExpMap.has(pattern)) {
+        const ri = ctx.varCounter++
+        ctx.regExpMap.set(pattern, ri)
+        ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`);
+      }
+      const ri = ctx.regExpMap.get(pattern);
       lines.push(`if(!_re${ri}.test(_k${ki})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
     }
     if (pn.const !== undefined) {
@@ -2746,7 +2776,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap) {
     }
   }
 
-  const ctx = { varCounter: 0, helperCode: [], closureVars: [], closureVals: [],
+  const ctx = { varCounter: 0, helperCode: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
                 rootDefs: cRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: cAnchors, rootSchema: schema }
   const lines = []
   genCodeC(schema, 'd', '', lines, ctx, '#')
@@ -2963,8 +2993,8 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 
   // string — skip guard if known
-  if (schema.minLength !== undefined) { const c = isStr ? `${v}.length<${schema.minLength}` : `typeof ${v}==='string'&&${v}.length<${schema.minLength}`; lines.push(`if(${c}){${fail('minLength', 'minLength', `{limit:${schema.minLength}}`, `'must NOT have fewer than ${schema.minLength} characters'`)}}`) }
-  if (schema.maxLength !== undefined) { const c = isStr ? `${v}.length>${schema.maxLength}` : `typeof ${v}==='string'&&${v}.length>${schema.maxLength}`; lines.push(`if(${c}){${fail('maxLength', 'maxLength', `{limit:${schema.maxLength}}`, `'must NOT have more than ${schema.maxLength} characters'`)}}`) }
+  if (schema.minLength !== undefined) { const c = isStr ? `_cpLen(${v})<${schema.minLength}` : `typeof ${v}==='string'&&_cpLen(${v})<${schema.minLength}`; lines.push(`if(${c}){${fail('minLength', 'minLength', `{limit:${schema.minLength}}`, `'must NOT have fewer than ${schema.minLength} characters'`)}}`) }
+  if (schema.maxLength !== undefined) { const c = isStr ? `_cpLen(${v})>${schema.maxLength}` : `typeof ${v}==='string'&&_cpLen(${v})>${schema.maxLength}`; lines.push(`if(${c}){${fail('maxLength', 'maxLength', `{limit:${schema.maxLength}}`, `'must NOT have more than ${schema.maxLength} characters'`)}}`) }
   if (schema.pattern) {
     const inlineCheck = compilePatternInline(schema.pattern, v)
     if (inlineCheck) {

package/lib/tier0.js

@@ -17,6 +17,14 @@ const T_NUMBER = TYPE_MASK.number;
 const T_INTEGER = TYPE_MASK.integer;
 const T_BOOLEAN = TYPE_MASK.boolean;
 
+// Count Unicode code points, not UTF-16 code units.
+// JSON Schema spec: minLength/maxLength count characters (RFC 8259 = code points).
+function codePointLength(s) {
+  let n = 0;
+  for (const _ of s) n++;
+  return n;
+}
+
 // Numeric constraint flags, packed into constraint.numFlags.
 // Using bit flags means the validator does a cheap bitwise-and instead of
 // five Number.isNaN() calls per numeric property when only one bound is set.
@@ -94,8 +102,8 @@ function checkPrimitive(c, v) {
     if (typeof v !== 'string') return false;
     const minLen = c.minLen;
     const maxLen = c.maxLen;
-    if (minLen >= 0 && v.length < minLen) return false;
-    if (maxLen >= 0 && v.length > maxLen) return false;
+    if (minLen >= 0 && codePointLength(v) < minLen) return false;
+    if (maxLen >= 0 && codePointLength(v) > maxLen) return false;
   } else if (m === T_INTEGER) {
     if (typeof v !== 'number' || !Number.isInteger(v)) return false;
     const f = c.numFlags;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "Ultra-fast JSON Schema validator. 4.7x faster validation, 1,800x faster compilation. Works without native addon. Cross-schema $ref, Draft 2020-12 + Draft 7, V8-optimized JS codegen, simdjson, RE2, multi-core. Standard Schema V1 compatible.",
   "main": "index.js",
   "module": "index.mjs",