ata-validator 0.9.3 → 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/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/index.js

@@ -9,6 +9,8 @@ const {
   compileToJSCombined,
 } = require("./lib/js-compiler");
 const { normalizeDraft7 } = require("./lib/draft7");
+const { classify } = require("./lib/shape-classifier");
+const { buildTier0Plan, tier0Validate } = require("./lib/tier0");
 
 // 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.
@@ -413,6 +415,20 @@ class Validator {
       enumerable: false,
       configurable: false,
     });
+
+    // Tier 0 fast path: override isValidObject with a direct bound validator.
+    // All other methods (validate, validateJSON, etc.) stay on the lazy stubs above.
+    // Tier 0/1 are boolean-only; error paths continue through codegen.
+    const _tier = classify(schemaObj);
+    if (_tier.tier === 0) {
+      const _plan = buildTier0Plan(schemaObj);
+      this.isValidObject = (data) => tier0Validate(_plan, data);
+    }
+
+    // Populate identity cache so repeated `new Validator(sameSchema)` short-circuits.
+    if (!opts && typeof schema === "object" && schema !== null) {
+      _identityCache.set(schema, this);
+    }
   }
 
   _ensureCompiled() {

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/shape-classifier.js

@@ -0,0 +1,96 @@
+'use strict';
+
+// Classifies a JSON Schema into one of three execution tiers:
+//   0 - simple object or top-level primitive, fast-path validator
+//   1 - nested objects/arrays, no composition, generic interpreter
+//   2 - composition, $ref, dynamic, etc. -> existing codegen
+//
+// Tier 0/1 validators are BOOLEAN only. Error-returning paths stay on codegen.
+
+const PRIMITIVE_TYPES = new Set(['string', 'number', 'integer', 'boolean']);
+
+// Meta keywords that are always safe to see at any node (annotations, no validation impact)
+const META_KEYS = new Set([
+  '$schema', '$id', '$comment',
+  'title', 'description', 'default', 'examples', 'deprecated', 'readOnly', 'writeOnly',
+]);
+
+const TIER0_OBJECT_ALLOWED = new Set([
+  'type', 'properties', 'required', 'additionalProperties',
+  ...META_KEYS,
+]);
+
+const TIER0_PRIMITIVE_ALLOWED = new Set([
+  'type', 'enum', 'const',
+  'minLength', 'maxLength',
+  'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum',
+  'multipleOf', 'format',
+  ...META_KEYS,
+]);
+
+const MAX_TIER0_PROPS = 10;
+const MAX_TIER0_ENUM = 256;
+
+function isPrimitiveType(t) {
+  return typeof t === 'string' && PRIMITIVE_TYPES.has(t);
+}
+
+function isPrimitiveEnumValue(v) {
+  const t = typeof v;
+  return v === null || t === 'string' || t === 'number' || t === 'boolean';
+}
+
+function isTier0Primitive(schema) {
+  if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) return false;
+  if (!isPrimitiveType(schema.type)) return false;
+  for (const k of Object.keys(schema)) {
+    if (!TIER0_PRIMITIVE_ALLOWED.has(k)) return false;
+  }
+  if (schema.enum !== undefined) {
+    if (!Array.isArray(schema.enum)) return false;
+    if (schema.enum.length === 0 || schema.enum.length > MAX_TIER0_ENUM) return false;
+    for (const v of schema.enum) {
+      if (!isPrimitiveEnumValue(v)) return false;
+    }
+  }
+  if (schema.const !== undefined && !isPrimitiveEnumValue(schema.const)) return false;
+  return true;
+}
+
+function isTier0Object(schema) {
+  if (schema.type !== 'object') return false;
+  for (const k of Object.keys(schema)) {
+    if (!TIER0_OBJECT_ALLOWED.has(k)) return false;
+  }
+  const ap = schema.additionalProperties;
+  if (ap !== undefined && ap !== true && ap !== false) return false;
+  if (schema.required !== undefined) {
+    if (!Array.isArray(schema.required)) return false;
+    for (const r of schema.required) if (typeof r !== 'string') return false;
+  }
+  const props = schema.properties;
+  if (props === undefined) return true;
+  if (typeof props !== 'object' || props === null || Array.isArray(props)) return false;
+  const keys = Object.keys(props);
+  if (keys.length > MAX_TIER0_PROPS) return false;
+  for (const k of keys) {
+    if (!isTier0Primitive(props[k])) return false;
+  }
+  return true;
+}
+
+function classify(schema) {
+  if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) {
+    return { tier: 2, plan: null };
+  }
+  if (isTier0Primitive(schema)) return { tier: 0, plan: null };
+  if (isTier0Object(schema)) return { tier: 0, plan: null };
+  return { tier: 2, plan: null };
+}
+
+module.exports = {
+  classify,
+  MAX_TIER0_PROPS,
+  MAX_TIER0_ENUM,
+  PRIMITIVE_TYPES,
+};

package/lib/tier0.js

@@ -0,0 +1,211 @@
+'use strict';
+
+// Tier 0 fast path: shared parametric validator for simple schemas.
+// All tier-0 Validators call the same tier0Validate() function;
+// the per-instance difference is the plan object.
+// V8 sees one function with monomorphic hidden classes and JIT-compiles it once.
+
+const TYPE_MASK = {
+  string: 1,
+  number: 2,
+  integer: 4,
+  boolean: 8,
+};
+
+const T_STRING = TYPE_MASK.string;
+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.
+const F_MIN = 1;
+const F_MAX = 2;
+const F_EXCL_MIN = 4;
+const F_EXCL_MAX = 8;
+const F_MULT = 16;
+
+// Build a constraint tuple for one primitive-typed property.
+// All fields have the same layout so every constraint shares one hidden class.
+function primConstraint(key, propSchema) {
+  const t = propSchema.type;
+  const hasEnum = Array.isArray(propSchema.enum);
+  const hasConst = propSchema.const !== undefined;
+  let numFlags = 0;
+  if (typeof propSchema.minimum === 'number') numFlags |= F_MIN;
+  if (typeof propSchema.maximum === 'number') numFlags |= F_MAX;
+  if (typeof propSchema.exclusiveMinimum === 'number') numFlags |= F_EXCL_MIN;
+  if (typeof propSchema.exclusiveMaximum === 'number') numFlags |= F_EXCL_MAX;
+  if (typeof propSchema.multipleOf === 'number') numFlags |= F_MULT;
+  return {
+    key,
+    typeMask: TYPE_MASK[t] | 0,
+    numFlags,
+    hasEnum,
+    hasConst,
+    enumSet: hasEnum ? new Set(propSchema.enum) : null,
+    constVal: hasConst ? propSchema.const : undefined,
+    minLen: typeof propSchema.minLength === 'number' ? propSchema.minLength : -1,
+    maxLen: typeof propSchema.maxLength === 'number' ? propSchema.maxLength : -1,
+    min: typeof propSchema.minimum === 'number' ? propSchema.minimum : 0,
+    max: typeof propSchema.maximum === 'number' ? propSchema.maximum : 0,
+    exclMin: typeof propSchema.exclusiveMinimum === 'number' ? propSchema.exclusiveMinimum : 0,
+    exclMax: typeof propSchema.exclusiveMaximum === 'number' ? propSchema.exclusiveMaximum : 0,
+    multipleOf: typeof propSchema.multipleOf === 'number' ? propSchema.multipleOf : 0,
+  };
+}
+
+function buildTier0Plan(schema) {
+  if (schema.type !== 'object') {
+    return {
+      isPrimitive: true,
+      constraints: [primConstraint('__root__', schema)],
+      requiredMask: 0,
+      additionalAllowed: true,
+      knownKeys: null,
+    };
+  }
+  const props = schema.properties || {};
+  const keys = Object.keys(props);
+  const required = schema.required ? new Set(schema.required) : null;
+  const constraints = new Array(keys.length);
+  const knownKeys = new Set();
+  let requiredMask = 0;
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i];
+    constraints[i] = primConstraint(k, props[k]);
+    knownKeys.add(k);
+    if (required && required.has(k)) requiredMask |= (1 << i);
+  }
+  return {
+    isPrimitive: false,
+    constraints,
+    requiredMask,
+    additionalAllowed: schema.additionalProperties !== false,
+    knownKeys,
+  };
+}
+
+// checkPrimitive stays exported for Tier 1 reuse.
+function checkPrimitive(c, v) {
+  const m = c.typeMask;
+  if (m === T_STRING) {
+    if (typeof v !== 'string') return false;
+    const minLen = c.minLen;
+    const maxLen = c.maxLen;
+    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;
+    if (f !== 0) {
+      if ((f & F_MIN) && v < c.min) return false;
+      if ((f & F_MAX) && v > c.max) return false;
+      if ((f & F_EXCL_MIN) && v <= c.exclMin) return false;
+      if ((f & F_EXCL_MAX) && v >= c.exclMax) return false;
+      if ((f & F_MULT) && v % c.multipleOf !== 0) return false;
+    }
+  } else if (m === T_NUMBER) {
+    if (typeof v !== 'number') return false;
+    const f = c.numFlags;
+    if (f !== 0) {
+      if ((f & F_MIN) && v < c.min) return false;
+      if ((f & F_MAX) && v > c.max) return false;
+      if ((f & F_EXCL_MIN) && v <= c.exclMin) return false;
+      if ((f & F_EXCL_MAX) && v >= c.exclMax) return false;
+      if ((f & F_MULT) && v % c.multipleOf !== 0) return false;
+    }
+  } else if (m === T_BOOLEAN) {
+    if (typeof v !== 'boolean') return false;
+  } else {
+    return false;
+  }
+  if (c.hasEnum && !c.enumSet.has(v)) return false;
+  if (c.hasConst && v !== c.constVal) return false;
+  return true;
+}
+
+// Inlined object validator. Separating the primitive path removes a dead
+// branch from the hot object path.
+function tier0ValidateObject(plan, data) {
+  if (typeof data !== 'object' || data === null || Array.isArray(data)) return false;
+  const cs = plan.constraints;
+  const n = cs.length;
+  const reqMask = plan.requiredMask;
+  let seenMask = 0;
+  for (let i = 0; i < n; i++) {
+    const c = cs[i];
+    const v = data[c.key];
+    if (v === undefined) {
+      if (reqMask & (1 << i)) return false;
+      continue;
+    }
+    seenMask |= (1 << i);
+    // Inlined type + constraint check
+    const m = c.typeMask;
+    if (m === T_STRING) {
+      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;
+    } else if (m === T_INTEGER) {
+      if (typeof v !== 'number' || !Number.isInteger(v)) return false;
+      const f = c.numFlags;
+      if (f !== 0) {
+        if ((f & F_MIN) && v < c.min) return false;
+        if ((f & F_MAX) && v > c.max) return false;
+        if ((f & F_EXCL_MIN) && v <= c.exclMin) return false;
+        if ((f & F_EXCL_MAX) && v >= c.exclMax) return false;
+        if ((f & F_MULT) && v % c.multipleOf !== 0) return false;
+      }
+    } else if (m === T_NUMBER) {
+      if (typeof v !== 'number') return false;
+      const f = c.numFlags;
+      if (f !== 0) {
+        if ((f & F_MIN) && v < c.min) return false;
+        if ((f & F_MAX) && v > c.max) return false;
+        if ((f & F_EXCL_MIN) && v <= c.exclMin) return false;
+        if ((f & F_EXCL_MAX) && v >= c.exclMax) return false;
+        if ((f & F_MULT) && v % c.multipleOf !== 0) return false;
+      }
+    } else if (m === T_BOOLEAN) {
+      if (typeof v !== 'boolean') return false;
+    } else {
+      return false;
+    }
+    if (c.hasEnum && !c.enumSet.has(v)) return false;
+    if (c.hasConst && v !== c.constVal) return false;
+  }
+  if ((seenMask & reqMask) !== reqMask) return false;
+  if (!plan.additionalAllowed) {
+    const known = plan.knownKeys;
+    for (const k in data) {
+      if (!Object.prototype.hasOwnProperty.call(data, k)) continue;
+      if (!known.has(k)) return false;
+    }
+  }
+  return true;
+}
+
+function tier0Validate(plan, data) {
+  if (plan.isPrimitive) return checkPrimitive(plan.constraints[0], data);
+  return tier0ValidateObject(plan, data);
+}
+
+module.exports = {
+  buildTier0Plan,
+  tier0Validate,
+  tier0ValidateObject,
+  checkPrimitive,
+  TYPE_MASK,
+};

package/package.json

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