ata-validator 0.10.0 → 0.10.2

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/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,20 @@
 // 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.
+// Fast path: if no surrogate pairs exist, .length is correct (covers >99% of real data).
+function _cpLen(s) {
+  const len = s.length;
+  for (let i = 0; i < len; i++) {
+    if (s.charCodeAt(i) >= 0xD800 && s.charCodeAt(i) <= 0xDBFF) {
+      // Found a high surrogate — count code points the slow way
+      let n = 0; for (const _ of s) n++; return n;
+    }
+  }
+  return len;
+}
+
 // AJV-compatible error message templates (compile-time, not runtime)
 const AJV_MESSAGES = {
   type: (p) => `must be ${p.type}`,
@@ -271,11 +285,12 @@ function compileToJS(schema, defs, schemaMap) {
   // string
   if (schema.minLength !== undefined) {
     const min = schema.minLength
-    checks.push((d) => typeof d !== 'string' || d.length >= min)
+    const min2 = min * 2
+    checks.push((d) => typeof d !== 'string' || d.length >= min2 || (d.length >= min && _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' || d.length <= max || _cpLen(d) <= max)
   }
   if (schema.pattern) {
     try {
@@ -775,7 +790,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 +929,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 +971,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 +1177,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 +1194,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 +2287,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 +2320,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 +2466,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 +2479,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 +2570,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 +2606,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 +2787,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 +3004,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/schema-parser.js

@@ -0,0 +1,223 @@
+'use strict';
+
+// Schema-compiled JSON parser: combines parse + validate in one pass.
+// For known-shape schemas, skips JSON.parse entirely and builds typed
+// JS objects directly from the JSON string.
+//
+// Returns null on invalid JSON or validation failure.
+// Falls back to JSON.parse for unsupported schemas.
+
+function compileSchemaParser(schema) {
+  if (!schema || typeof schema !== 'object') return null;
+
+  // Array of objects
+  if (schema.type === 'array' && schema.items && schema.items.type === 'object') {
+    const itemParser = compileSchemaParser(schema.items);
+    if (!itemParser) return null;
+    return function parseArray(str) {
+      const len = str.length;
+      let pos = 0;
+      while (pos < len && str.charCodeAt(pos) <= 32) pos++;
+      if (str.charCodeAt(pos) !== 91) return null; // [
+      pos++;
+      const arr = [];
+      let first = true;
+      while (pos < len) {
+        while (pos < len && str.charCodeAt(pos) <= 32) pos++;
+        if (str.charCodeAt(pos) === 93) return arr; // ]
+        if (!first) {
+          if (str.charCodeAt(pos) !== 44) return null;
+          pos++;
+          while (pos < len && str.charCodeAt(pos) <= 32) pos++;
+        }
+        first = false;
+        // Parse nested object inline
+        const result = parseObject(str, pos, itemParser._keys, itemParser._keyTypes, itemParser._required, itemParser._additionalAllowed);
+        if (result === null) return null;
+        arr.push(result.value);
+        pos = result.pos;
+      }
+      return null;
+    };
+  }
+
+  // Wrapper object containing array
+  if (schema.type === 'object' && schema.properties) {
+    const props = schema.properties;
+    const keys = Object.keys(props);
+    for (const k of keys) {
+      if (props[k] && props[k].type === 'array' && props[k].items) {
+        // Has nested array — use the general parser
+        return compileObjectParser(schema);
+      }
+    }
+    return compileObjectParser(schema);
+  }
+
+  return null;
+}
+
+function compileObjectParser(schema) {
+  if (!schema.properties) return null;
+  const props = schema.properties;
+  const keys = Object.keys(props);
+  const required = new Set(schema.required || []);
+  const additionalAllowed = schema.additionalProperties !== false;
+
+  // Build a key→type map for O(1) lookup
+  const keyTypes = {};
+  for (const k of keys) {
+    const p = props[k];
+    if (!p || typeof p.type !== 'string') return null; // bail on complex
+    if (p.type === 'object' || p.type === 'array') return null; // flat only for now
+    keyTypes[k] = p;
+  }
+
+  // The compiled parser function
+  return function parseAndValidate(str) {
+    const len = str.length;
+    let pos = 0;
+
+    // Skip whitespace
+    while (pos < len && (str.charCodeAt(pos) <= 32)) pos++;
+    if (pos >= len || str.charCodeAt(pos) !== 123) return null; // {
+    pos++;
+
+    const result = {};
+    let foundKeys = 0;
+    let first = true;
+
+    while (pos < len) {
+      // Skip whitespace
+      while (pos < len && str.charCodeAt(pos) <= 32) pos++;
+      if (str.charCodeAt(pos) === 125) break; // }
+
+      // Comma between entries
+      if (!first) {
+        if (str.charCodeAt(pos) !== 44) return null; // ,
+        pos++;
+        while (pos < len && str.charCodeAt(pos) <= 32) pos++;
+      }
+      first = false;
+
+      // Key
+      if (str.charCodeAt(pos) !== 34) return null; // "
+      pos++;
+      const keyStart = pos;
+      while (pos < len && str.charCodeAt(pos) !== 34) {
+        if (str.charCodeAt(pos) === 92) pos++; // skip escape
+        pos++;
+      }
+      const key = str.substring(keyStart, pos);
+      pos++; // closing "
+
+      // Colon
+      while (pos < len && str.charCodeAt(pos) <= 32) pos++;
+      if (str.charCodeAt(pos) !== 58) return null; // :
+      pos++;
+      while (pos < len && str.charCodeAt(pos) <= 32) pos++;
+
+      // Value — parse based on schema type if known key
+      const propSchema = keyTypes[key];
+      if (propSchema) {
+        const parsed = parseValue(str, pos, propSchema);
+        if (parsed === null) return null; // validation fail
+        result[key] = parsed.value;
+        pos = parsed.pos;
+        foundKeys++;
+      } else if (!additionalAllowed) {
+        return null; // additional property not allowed
+      } else {
+        // Skip unknown value
+        const skipped = skipValue(str, pos);
+        if (skipped < 0) return null;
+        pos = skipped;
+      }
+    }
+
+    // Check required
+    for (const r of required) {
+      if (result[r] === undefined) return null;
+    }
+
+    return result;
+  };
+}
+
+function parseValue(str, pos, schema) {
+  const ch = str.charCodeAt(pos);
+  const type = schema.type;
+
+  if (type === 'string') {
+    if (ch !== 34) return null; // must be "
+    pos++;
+    const start = pos;
+    while (pos < str.length && str.charCodeAt(pos) !== 34) {
+      if (str.charCodeAt(pos) === 92) pos++; // skip escape
+      pos++;
+    }
+    const val = str.substring(start, pos);
+    pos++; // closing "
+    if (schema.minLength !== undefined && val.length < schema.minLength) return null;
+    if (schema.maxLength !== undefined && val.length > schema.maxLength) return null;
+    return { value: val, pos };
+  }
+
+  if (type === 'integer' || type === 'number') {
+    const start = pos;
+    if (str.charCodeAt(pos) === 45) pos++; // -
+    while (pos < str.length && str.charCodeAt(pos) >= 48 && str.charCodeAt(pos) <= 57) pos++;
+    if (type === 'number' && str.charCodeAt(pos) === 46) {
+      pos++;
+      while (pos < str.length && str.charCodeAt(pos) >= 48 && str.charCodeAt(pos) <= 57) pos++;
+    }
+    const val = +str.substring(start, pos);
+    if (type === 'integer' && !Number.isInteger(val)) return null;
+    if (schema.minimum !== undefined && val < schema.minimum) return null;
+    if (schema.maximum !== undefined && val > schema.maximum) return null;
+    return { value: val, pos };
+  }
+
+  if (type === 'boolean') {
+    if (str.startsWith('true', pos)) return { value: true, pos: pos + 4 };
+    if (str.startsWith('false', pos)) return { value: false, pos: pos + 5 };
+    return null;
+  }
+
+  return null;
+}
+
+function skipValue(str, pos) {
+  const ch = str.charCodeAt(pos);
+  if (ch === 34) { // string
+    pos++;
+    while (pos < str.length && str.charCodeAt(pos) !== 34) {
+      if (str.charCodeAt(pos) === 92) pos++;
+      pos++;
+    }
+    return pos + 1;
+  }
+  if (ch === 123 || ch === 91) { // { or [
+    let depth = 1;
+    const open = ch;
+    const close = ch === 123 ? 125 : 93;
+    pos++;
+    while (pos < str.length && depth > 0) {
+      const c = str.charCodeAt(pos);
+      if (c === open) depth++;
+      else if (c === close) depth--;
+      else if (c === 34) { pos++; while (pos < str.length && str.charCodeAt(pos) !== 34) { if (str.charCodeAt(pos) === 92) pos++; pos++; } }
+      pos++;
+    }
+    return pos;
+  }
+  // number, true, false, null
+  while (pos < str.length) {
+    const c = str.charCodeAt(pos);
+    if (c === 44 || c === 125 || c === 93 || c <= 32) break;
+    pos++;
+  }
+  return pos;
+}
+
+module.exports = { compileSchemaParser };

package/lib/shape-classifier.js

@@ -24,7 +24,7 @@ const TIER0_PRIMITIVE_ALLOWED = new Set([
   'type', 'enum', 'const',
   'minLength', 'maxLength',
   'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum',
-  'multipleOf', 'format',
+  'multipleOf',
   ...META_KEYS,
 ]);
 

package/lib/tier0.js

@@ -17,6 +17,19 @@ 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).
+// Fast path: scan for surrogates first, skip slow iteration for ASCII-only strings.
+function codePointLength(s) {
+  const len = s.length;
+  for (let i = 0; i < len; i++) {
+    if (s.charCodeAt(i) >= 0xD800 && s.charCodeAt(i) <= 0xDBFF) {
+      let n = 0; for (const _ of s) n++; return n;
+    }
+  }
+  return len;
+}
+
 // 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 +107,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) { const l = v.length; if (l < minLen) return false; if (l < minLen * 2 && codePointLength(v) < minLen) return false; }
+    if (maxLen >= 0) { const l = v.length; if (l > maxLen && codePointLength(v) > maxLen) return false; }
   } else if (m === T_INTEGER) {
     if (typeof v !== 'number' || !Number.isInteger(v)) return false;
     const f = c.numFlags;
@@ -148,8 +161,8 @@ function tier0ValidateObject(plan, data) {
       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) { const l = v.length; if (l < minLen) return false; if (l < minLen * 2 && codePointLength(v) < minLen) return false; }
+      if (maxLen >= 0) { const l = v.length; if (l > maxLen && 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.2",
   "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",