ata-validator 1.9.0 → 1.10.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to ata-validator are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/), and this project adheres to semantic versioning.
 
+## 1.10.0 - 2026-08-30
+
+### Performance
+
+- The code generator takes shapes it used to decline for no correctness reason: boolean subschemas in `items`, `properties`, `patternProperties`, `dependentSchemas`, `propertyNames`, `allOf`, `anyOf`, `not`, `contains` and `if`/`then`/`else`, recursive `#/$defs/` references as named functions, and `additionalProperties` as a schema alongside composition or `patternProperties`. Each lands in all three generators and the closure path, held to the interpreter by `tests/test_codegen_edge_shapes.js` and the entry-point agreement test over the whole official suite. Every suite group that moved off the interpreter got faster, 31 of 31 on draft 2020-12 and 28 of 28 on draft 7, summed per-group time down 70 percent. The suite-wide figure, measured interleaved against the previous release in one process, did not move outside that measurement's noise; `benchmark/verdict-bench.md` has the numbers and says why.
+- `date` and `ipv4` format checks read the string once with no regular expression and no allocation: 45.7 to 14.2 ns and 54.5 to 27.1 ns on a valid value, interleaved medians. Fuzzed against the previous forms with 0 mismatches; `tests/test_formats_single_pass.js` keeps it that way.
+
+### Fixed
+
+- A key matched only by the second of two `patternProperties` entries, alongside `additionalProperties: false`, was rejected: the generated key loop returned at the first pattern that missed. Found while rewriting that loop; covered by the edge-shape test.
+- A declared property that also matched a `patternProperties` entry skipped the pattern's schema in the generated code when `additionalProperties` was a schema. The suite's own interaction case caught it the moment the shape was allowed to compile.
+
 ## 1.9.0 - 2026-08-28
 
 ### Errors

package/lib/formats.js

@@ -0,0 +1,57 @@
+'use strict';
+
+// Format predicates that read the string once, with no regular expression
+// and no allocation. Each has a twin that emits the same check as source for
+// the code generator; tests/test_formats_single_pass.js holds the two
+// together and fuzzes both against the regular-expression forms they replaced.
+// Measured, interleaved medians: date 45.7 to 14.2 ns, ipv4 54.5 to 27.1 ns.
+// uuid was tried the same way and measured 57.3 against 59.4 ns: V8's regular
+// expression for a fixed-length hex pattern is already that fast, so it stays.
+
+function isDigit (c) { return c >= 48 && c <= 57; }
+
+function date (s) {
+  if (s.length !== 10) return false;
+  for (let i = 0; i < 10; i++) {
+    const c = s.charCodeAt(i);
+    if (i === 4 || i === 7) { if (c !== 45) return false; } else if (!isDigit(c)) return false;
+  }
+  const m = (s.charCodeAt(5) - 48) * 10 + (s.charCodeAt(6) - 48);
+  const d = (s.charCodeAt(8) - 48) * 10 + (s.charCodeAt(9) - 48);
+  return m >= 1 && m <= 12 && d >= 1 && d <= 31;
+}
+
+// Four decimal octets, no leading zeros, no empty octets, nothing else.
+function ipv4 (s) {
+  const n = s.length;
+  if (n < 7 || n > 15) return false;
+  let octets = 0, value = 0, digits = 0;
+  for (let i = 0; i <= n; i++) {
+    const c = i < n ? s.charCodeAt(i) : 46;
+    if (c === 46) {
+      if (digits === 0 || value > 255) return false;
+      octets++; value = 0; digits = 0;
+      if (octets > 4) return false;
+    } else if (isDigit(c)) {
+      if (digits === 1 && value === 0) return false;
+      value = value * 10 + (c - 48); digits++;
+      if (digits > 3) return false;
+    } else return false;
+  }
+  return octets === 4;
+}
+
+// Source twins. `v` is the expression holding the string; when `isStr` is
+// false the check is wrapped in a typeof guard, matching FORMAT_CODEGEN's
+// convention. Each returns a statement that `return false`s on mismatch.
+function guard (v, isStr, body) { return isStr ? `{${body}}` : `if(typeof ${v}==='string'){${body}}`; }
+
+function dateSource (v, isStr) {
+  return guard(v, isStr, `if(${v}.length!==10)return false;for(let _i=0;_i<10;_i++){const _c=${v}.charCodeAt(_i);if(_i===4||_i===7){if(_c!==45)return false}else if(_c<48||_c>57)return false}const _m=(${v}.charCodeAt(5)-48)*10+(${v}.charCodeAt(6)-48),_d=(${v}.charCodeAt(8)-48)*10+(${v}.charCodeAt(9)-48);if(_m<1||_m>12||_d<1||_d>31)return false`);
+}
+
+function ipv4Source (v, isStr) {
+  return guard(v, isStr, `const _n=${v}.length;if(_n<7||_n>15)return false;let _o=0,_val=0,_dg=0;for(let _i=0;_i<=_n;_i++){const _c=_i<_n?${v}.charCodeAt(_i):46;if(_c===46){if(_dg===0||_val>255)return false;_o++;_val=0;_dg=0;if(_o>4)return false}else if(_c>=48&&_c<=57){if(_dg===1&&_val===0)return false;_val=_val*10+(_c-48);_dg++;if(_dg>3)return false}else return false}if(_o!==4)return false`);
+}
+
+module.exports = { date, ipv4, dateSource, ipv4Source };

package/lib/interpreter.js

@@ -247,16 +247,17 @@ function multipleOfOk(d, m) {
   return Math.abs(q - Math.round(q)) < 1e-9;
 }
 
+const _formats = require('./formats');
 const FORMAT_CHECKS = {
   email: (s) => { const at = s.indexOf('@'); return at > 0 && at < s.length - 1 && s.indexOf('.', at) > at + 1; },
-  date: (s) => { if (s.length !== 10 || !/^\d{4}-\d{2}-\d{2}$/.test(s)) return false; const m = +s.slice(5, 7), d = +s.slice(8, 10); return m >= 1 && m <= 12 && d >= 1 && d <= 31; },
+  date: _formats.date,
   'date-time': (s) => /^\d{4}-\d{2}-\d{2}[Tt]\d{2}:\d{2}:\d{2}(\.\d+)?([Zz]|[+-]\d{2}:\d{2})$/.test(s) && !isNaN(Date.parse(s)),
   time: (s) => /^([01]\d|2[0-3]):[0-5]\d:[0-5]\d(\.\d+)?([Zz]|[+-]\d{2}:\d{2})?$/.test(s),
   duration: (s) => /^P(?:\d+Y)?(?:\d+M)?(?:\d+W)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+(?:\.\d+)?S)?)?$/.test(s) && s !== 'P' && !s.endsWith('T'),
   uuid: (s) => s.length === 36 && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s),
   uri: (s) => /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(s) && !/[\s\u0000-\u001f\u007f]/.test(s),
   'uri-reference': (s) => !/[\s\u0000-\u001f\u007f]/.test(s),
-  ipv4: (s) => { const p = s.split('.'); return p.length === 4 && p.every((n) => { const v = +n; return n !== '' && v >= 0 && v <= 255 && String(v) === n; }); },
+  ipv4: _formats.ipv4,
   ipv6: (s) => s !== '' && /^[0-9a-fA-F:.]+$/.test(s) && s.split(':').length >= 3 && s.split(':').length <= 8,
   hostname: (s) => s.length > 0 && s.length <= 253 && /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.test(s),
   regex: (s) => { try { new RegExp(s, 'u'); return true; } catch { try { new RegExp(s); return true; } catch { return false; } } },

package/lib/js-compiler.js

@@ -193,11 +193,13 @@ function compileToJS(schema, defs, schemaMap) {
   // Collect $defs early so sub-schemas can resolve $ref
   const rootDefs = defs || collectDefs(schema)
 
-  // Bail on features that are too complex for JS fast path
-  if (schema.patternProperties ||
-      schema.dependentSchemas ||
-      schema.propertyDependencies ||
-      schema.propertyNames) {
+  // Bail on features this path has no emitter for. Tested for presence, not
+  // truthiness: `propertyNames: false` is falsy, passed this bail, and then
+  // validated nothing, which the entry-point agreement test caught.
+  if (schema.patternProperties !== undefined ||
+      schema.dependentSchemas !== undefined ||
+      schema.propertyDependencies !== undefined ||
+      schema.propertyNames !== undefined) {
     return null
   }
 
@@ -328,7 +330,7 @@ function compileToJS(schema, defs, schemaMap) {
   }
 
   // items, applied after the prefixItems positions
-  if (schema.items) {
+  if (schema.items !== undefined && schema.items !== true) {
     const itemCheck = compileToJS(schema.items, rootDefs)
     if (!itemCheck) return null
     const start = Array.isArray(schema.prefixItems) ? schema.prefixItems.length : 0
@@ -359,7 +361,7 @@ function compileToJS(schema, defs, schemaMap) {
   }
 
   // contains
-  if (schema.contains) {
+  if (schema.contains !== undefined) {
     const containsCheck = compileToJS(schema.contains, rootDefs)
     if (!containsCheck) return null
     const minC = schema.minContains !== undefined ? schema.minContains : 1
@@ -517,20 +519,20 @@ function compileToJS(schema, defs, schemaMap) {
   }
 
   // not
-  if (schema.not) {
+  if (schema.not !== undefined) {
     const notFn = compileToJS(schema.not, rootDefs)
     if (!notFn) return null
     checks.push((d) => !notFn(d))
   }
 
   // if/then/else
-  if (schema.if) {
+  if (schema.if !== undefined) {
     const ifFn = compileToJS(schema.if, rootDefs)
     if (!ifFn) return null
-    const thenFn = schema.then ? compileToJS(schema.then, rootDefs) : null
-    const elseFn = schema.else ? compileToJS(schema.else, rootDefs) : null
-    if (schema.then && !thenFn) return null
-    if (schema.else && !elseFn) return null
+    const thenFn = schema.then !== undefined ? compileToJS(schema.then, rootDefs) : null
+    const elseFn = schema.else !== undefined ? compileToJS(schema.else, rootDefs) : null
+    if (schema.then !== undefined && !thenFn) return null
+    if (schema.else !== undefined && !elseFn) return null
     checks.push((d) => {
       if (ifFn(d)) {
         return thenFn ? thenFn(d) : true
@@ -756,11 +758,12 @@ function _canonical(x) {
   return '{' + Object.keys(x).sort().map((k) => JSON.stringify(k) + ':' + _canonical(x[k])).join(',') + '}'
 }
 
+const _formats = require('./formats')
 const FORMAT_CHECKS = {
   email: (s) => { const at = s.indexOf('@'); return at > 0 && at < s.length - 1 && s.indexOf('.', at) > at + 1 },
-  date: (s) => { if (s.length !== 10 || !/^\d{4}-\d{2}-\d{2}$/.test(s)) return false; const m = +s.slice(5, 7), d = +s.slice(8, 10); return m >= 1 && m <= 12 && d >= 1 && d <= 31 },
+  date: _formats.date,
   uuid: (s) => s.length === 36 && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s),
-  ipv4: (s) => { const p = s.split('.'); return p.length === 4 && p.every(n => { const v = +n; return v >= 0 && v <= 255 && String(v) === n }) },
+  ipv4: _formats.ipv4,
   hostname: (s) => s.length > 0 && s.length <= 253 && /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$/i.test(s),
 }
 
@@ -842,6 +845,51 @@ function hasNestedIdScope(node, isRoot = true) {
 
 // Recursively check if a schema can be safely compiled to JS codegen.
 // Returns false if any sub-schema contains features codegen gets wrong.
+// Names of the defs that sit on a $ref cycle among defs. Such a def compiles
+// as a named function rather than being inlined, so recursion terminates in
+// the generated code the same way `$ref: "#"` does at the root. A plain
+// cross-reference (A -> B where B does not refer back) is not on a cycle and
+// still inlines.
+function cyclicDefNames (defs) {
+  const out = new Set()
+  if (!defs || typeof defs !== 'object') return out
+  const defNames = new Set(Object.keys(defs))
+  const defRefs = {}
+  for (const [name, def] of Object.entries(defs)) {
+    const refs = []
+    const seen = new WeakSet()
+    const collectRefs = (node) => {
+      if (typeof node !== 'object' || node === null) return
+      if (seen.has(node)) return
+      seen.add(node)
+      if (node.$ref) {
+        const m = /^#\/(?:\$defs|definitions)\/([^/]+)$/.exec(node.$ref)
+        if (m && defNames.has(m[1])) refs.push(m[1])
+      }
+      for (const val of Object.values(node)) {
+        if (typeof val === 'object' && val !== null) {
+          if (Array.isArray(val)) { for (const item of val) collectRefs(item) } else collectRefs(val)
+        }
+      }
+    }
+    collectRefs(def)
+    defRefs[name] = refs
+  }
+  const visited = new Set()
+  const inStack = []
+  const dfs = (node) => {
+    const at = inStack.indexOf(node)
+    if (at !== -1) { for (let i = at; i < inStack.length; i++) out.add(inStack[i]); return }
+    if (visited.has(node)) return
+    visited.add(node)
+    inStack.push(node)
+    for (const neighbor of (defRefs[node] || [])) dfs(neighbor)
+    inStack.pop()
+  }
+  for (const name of Object.keys(defRefs)) dfs(name)
+  return out
+}
+
 function codegenSafe(schema, schemaMap) {
   if (typeof schema === 'boolean') return true
   if (typeof schema !== 'object' || schema === null) return true
@@ -855,13 +903,12 @@ function codegenSafe(schema, schemaMap) {
   if (schema.$dynamicRef && !schema.$dynamicRef.startsWith('#')) return false
 
   // Boolean sub-schemas anywhere cause bail — codegen doesn't handle schema=false correctly
-  if (schema.items === false) return false
-  if (schema.items === true && !schema.unevaluatedItems) return false
+  // items: false and items: true are constants; every generator handles a
+  // boolean child at its head, so neither falls through as "nothing".
   if (schema.additionalProperties === true) return true // permissive — fine
   if (schema.properties) {
     for (const v of Object.values(schema.properties)) {
-      if (v === false) return false // property: false is complex
-      if (v === true) continue // property: true is always valid
+      if (typeof v === 'boolean') continue // constants; every generator handles them at its head
       if (!codegenSafe(v, schemaMap)) return false
     }
   }
@@ -926,15 +973,17 @@ function codegenSafe(schema, schemaMap) {
   // additionalProperties as schema — supported when no composition (allOf/oneOf/anyOf)
   // is in play, and no patternProperties (unified loop does not emit the
   // per-key sub-schema walk yet). Closure path handles those cases.
+  // additionalProperties as a schema: emitted by the per-key walk, or by the
+  // unified key loop when patternProperties is present. Composition alongside
+  // it is fine, since additionalProperties only looks at this schema's own
+  // properties and patternProperties.
   if (typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null) {
-    if (schema.allOf || schema.oneOf || schema.anyOf) return false
-    if (schema.patternProperties) return false
     if (!codegenSafe(schema.additionalProperties, schemaMap)) return false
   }
   if (schema.additionalProperties === false && !schema.properties) return false
 
   // propertyNames: false — codegen doesn't handle this
-  if (schema.propertyNames === false) return false
+  // propertyNames: false is emitted as a per-key rejection by every generator.
 
   // unevaluatedProperties: allow boolean and schema values
   if (schema.unevaluatedProperties !== undefined) {
@@ -967,53 +1016,8 @@ function codegenSafe(schema, schemaMap) {
   const defs = schema.$defs || schema.definitions
   if (defs) {
     const defNames = new Set(Object.keys(defs))
-    // Detect cyclic local refs: build a directed graph of def->def references and
-    // check for cycles using DFS. A plain cross-reference (A -> B where B doesn't
-    // refer back to A) is fine; only true cycles (A -> B -> A) must be rejected.
-    // The JS codegen returns (() => true) on cycle (permissive), so cyclic schemas
-    // must route to the interpreted engine instead.
-    const defRefs = {}
-    for (const [name, def] of Object.entries(defs)) {
-      defRefs[name] = []
-      if (typeof def === 'object' && def !== null) {
-        const refs = []
-        const seen = new WeakSet()
-        const collectRefs = (node) => {
-          if (typeof node !== 'object' || node === null) return
-          if (seen.has(node)) return
-          seen.add(node)
-          if (node.$ref) {
-            const m = /^#\/(?:\$defs|definitions)\/([^/]+)$/.exec(node.$ref)
-            if (m && defNames.has(m[1])) refs.push(m[1])
-          }
-          for (const val of Object.values(node)) {
-            if (typeof val === 'object' && val !== null) {
-              if (Array.isArray(val)) { for (const item of val) collectRefs(item) }
-              else collectRefs(val)
-            }
-          }
-        }
-        collectRefs(def)
-        defRefs[name] = refs
-      }
-    }
-    const hasCycle = (() => {
-      const visited = new Set()
-      const inStack = new Set()
-      const dfs = (node) => {
-        if (inStack.has(node)) return true
-        if (visited.has(node)) return false
-        visited.add(node)
-        inStack.add(node)
-        for (const neighbor of (defRefs[node] || [])) {
-          if (dfs(neighbor)) return true
-        }
-        inStack.delete(node)
-        return false
-      }
-      return Object.keys(defRefs).some(dfs)
-    })()
-    if (hasCycle) return false
+    // Defs on a $ref cycle compile as named functions (see genCode); nothing
+    // to decline here. cyclicDefNames() is the walk that used to bail.
     for (const [name, def] of Object.entries(defs)) {
       if (/[~/"']/.test(name)) return false // special chars in def name
       if (typeof def === 'boolean') return false
@@ -1030,6 +1034,10 @@ function codegenSafe(schema, schemaMap) {
   }
 
   // Recurse into sub-schemas — bail on boolean schemas in any position
+  // A boolean subschema is a constant that every generator emits at its
+  // head with the child's own path. The emitters below test for presence,
+  // not truthiness, because `false` is falsy and a truthiness test would
+  // skip it and validate nothing.
   const subs = [
     schema.items, schema.contains, schema.not,
     schema.if, schema.then, schema.else,
@@ -1040,9 +1048,7 @@ function codegenSafe(schema, schemaMap) {
   ]
   if (typeof schema.additionalProperties === 'object') subs.push(schema.additionalProperties)
   for (const s of subs) {
-    if (s === undefined || s === null) continue
-    if (s === false) return false // boolean false sub-schema — complex
-    if (s === true) continue // boolean true sub-schema — always valid, fine
+    if (s === undefined || s === null || typeof s === 'boolean') continue
     if (!codegenSafe(s, schemaMap)) return false
   }
 
@@ -1330,7 +1336,6 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
   // patternProperties: bail only on boolean sub-schemas or unicode property escapes
   if (schema.patternProperties) {
     for (const [pat, sub] of Object.entries(schema.patternProperties)) {
-      if (typeof sub === 'boolean') return null
       if (/\\[pP]\{/.test(pat)) return null
       if (typeof sub === 'object' && sub !== null && !codegenSafe(sub, schemaMap)) return null
     }
@@ -1338,13 +1343,11 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
   // dependentSchemas: bail on boolean sub-schemas
   if (schema.dependentSchemas) {
     for (const sub of Object.values(schema.dependentSchemas)) {
-      if (typeof sub === 'boolean') return null
       if (typeof sub === 'object' && sub !== null && !codegenSafe(sub, schemaMap)) return null
     }
   }
   // propertyNames: only codegen simple string constraints
   if (schema.propertyNames) {
-    if (typeof schema.propertyNames === 'boolean') return null
     const pn = schema.propertyNames
     const supported = ['maxLength', 'minLength', 'pattern', 'const', 'enum']
     const keys = Object.keys(pn).filter(k => k !== '$schema')
@@ -1654,6 +1657,11 @@ function _deferOrInline(ctx, lines, v, check) {
 // 'array'  = we know v is an array
 // 'string' / 'number' / 'integer' = we know the primitive type
 function genCode(schema, v, lines, ctx, knownType) {
+  // A boolean schema is a constant. false rejects whatever reached it; true
+  // constrains nothing and emits nothing, which is correct only because the
+  // caller's own checks still stand around this call.
+  if (schema === false) { lines.push('return false'); return }
+  if (schema === true) return
   if (typeof schema !== 'object' || schema === null) return
   if (!ctx.regExpMap) {
     ctx.regExpMap = new Map();
@@ -1673,10 +1681,28 @@ function genCode(schema, v, lines, ctx, knownType) {
     // 1. Local ref
     const m = schema.$ref !== '#' && schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
     if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
-      if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return }
+      const defName = m[1]
+      if (!ctx.cyclicDefs) ctx.cyclicDefs = cyclicDefNames(ctx.rootDefs)
+      if (ctx.cyclicDefs.has(defName) && ctx.preamble) {
+        // A def on a cycle is a named function in the preamble, emitted once
+        // and called by name, so recursion terminates the way `$ref: "#"`
+        // does at the root. The name is registered before the body is
+        // generated so a self-reference inside it becomes a call.
+        if (!ctx.defFns) ctx.defFns = new Map()
+        let fnName = ctx.defFns.get(defName)
+        if (!fnName) {
+          fnName = '_def' + ctx.defFns.size + '_' + defName.replace(/[^A-Za-z0-9_]/g, '_')
+          ctx.defFns.set(defName, fnName)
+          const bodyLines = []
+          genCode(ctx.rootDefs[defName], 'd', bodyLines, ctx)
+          ctx.preamble.push(`function ${fnName}(d){${bodyLines.join('\n  ')}\n  return true}`)
+        }
+        lines.push(`if(!${fnName}(${v}))return false`)
+        if (!hasSiblings) return
+      } else if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return }
       else {
         ctx.refStack.add(schema.$ref)
-        genCode(ctx.rootDefs[m[1]], v, lines, ctx, knownType)
+        genCode(ctx.rootDefs[defName], v, lines, ctx, knownType)
         ctx.refStack.delete(schema.$ref)
         if (!hasSiblings) return
       }
@@ -2048,11 +2074,23 @@ function genCode(schema, v, lines, ctx, knownType) {
 
     const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
 
-    if (schema.additionalProperties === false && schema.properties) {
-      // Unified loop: properties + patterns + propertyNames + additionalProperties
+    const apSchema = typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null ? schema.additionalProperties : null
+    if ((schema.additionalProperties === false && schema.properties) || apSchema) {
+      // Unified loop: properties + patterns + propertyNames + additionalProperties.
+      // A key that is neither declared nor matched by any pattern is
+      // additional: rejected outright, or run through the additionalProperties
+      // schema when there is one.
       ctx._ppHandledAdditional = true
       ctx._ppHandledPropertyNames = !!pn
-      const propKeys = Object.keys(schema.properties)
+      const propKeys = Object.keys(schema.properties || {})
+      let apFn = null
+      if (apSchema) {
+        const apLines = []
+        genCode(apSchema, '_apv', apLines, ctx)
+        apFn = `_apf${pi}`
+        ctx.closureVars.push(apFn)
+        ctx.closureVals.push(new Function('_apv', apLines.length === 0 ? 'return true' : `${apLines.join(';')};return true`))
+      }
       lines.push(`${guard}{for(const ${kVar} in ${v}){`)
       // propertyNames checks (merged into same loop)
       if (pn) {
@@ -2077,21 +2115,29 @@ function genCode(schema, v, lines, ctx, knownType) {
           lines.push(`if(!_es${ei}.has(${kVar}))return false`)
         }
       }
-      // Check: is key declared or matches a pattern?
-      // switch/case: V8 compiles string cases to jump table (faster than chained ===)
-      const switchCases = propKeys.map(k => `case ${JSON.stringify(k)}:`).join('')
-      lines.push(`switch(${kVar}){${switchCases}break;default:`)
-      // Default: key is not declared — must match a pattern
-      let patternChecks = []
-      for (let i = 0; i < ppEntries.length; i++) {
-        patternChecks.push(`if(${matchers[i].check}){if(!_ppf${pi}_${i}(${v}[${kVar}]))return false}else{return false}`)
+      // Every matching pattern applies to every key, declared or not: a
+      // declared key that also matches a pattern is validated by both (the
+      // properties emitter handles its own subschema). A flag rather than an
+      // if/else chain, because a chain returned false at the first pattern
+      // that missed and wrongly rejected a key only a later pattern matched.
+      if (ppEntries.length > 0) {
+        lines.push(`let _pm${pi}=false`)
+        for (let i = 0; i < ppEntries.length; i++) {
+          lines.push(`if(${matchers[i].check}){_pm${pi}=true;if(!_ppf${pi}_${i}(${v}[${kVar}]))return false}`)
+        }
       }
-      if (patternChecks.length > 0) {
-        lines.push(patternChecks.join(''))
+      // A key that is neither declared nor matched is additional. switch on
+      // the declared names (V8 compiles string cases to a jump table); no
+      // switch at all when nothing is declared, since a switch with no case
+      // clause is a syntax error.
+      const additional = apFn ? `if(!${apFn}(${v}[${kVar}]))return false` : `return false`
+      const notMatched = ppEntries.length > 0 ? `if(!_pm${pi}){${additional}}` : additional
+      if (propKeys.length) {
+        const switchCases = propKeys.map(k => `case ${JSON.stringify(k)}:`).join('')
+        lines.push(`switch(${kVar}){${switchCases}break;default:{${notMatched}}}`)
       } else {
-        lines.push(`return false`)
+        lines.push(notMatched)
       }
-      lines.push(`}`) // end switch
       lines.push(`}}`)
     } else {
       // No additionalProperties: validate matching keys + propertyNames
@@ -2139,6 +2185,13 @@ function genCode(schema, v, lines, ctx, knownType) {
     }
   }
 
+  // propertyNames: false rejects any key at all; true constrains nothing.
+  if (schema.propertyNames === false) {
+    lines.push(isObj
+      ? `for(const _k in ${v})return false`
+      : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k in ${v})return false}`)
+  }
+
   // propertyNames — only emit if not already merged into patternProperties loop
   if (schema.propertyNames && typeof schema.propertyNames === 'object' && !ctx._ppHandledPropertyNames) {
     const pn = schema.propertyNames
@@ -2207,7 +2260,7 @@ function genCode(schema, v, lines, ctx, knownType) {
   }
 
   // items — pass known type info to children
-  if (schema.items) {
+  if (schema.items !== undefined && schema.items !== true) {
     const idx = `_j${ctx.varCounter}`
     const elem = `_e${ctx.varCounter}`
     ctx.varCounter++
@@ -2234,7 +2287,7 @@ function genCode(schema, v, lines, ctx, knownType) {
   }
 
   // contains — use helper function to avoid try/catch overhead
-  if (schema.contains) {
+  if (schema.contains !== undefined) {
     const ci = ctx.varCounter++
     const minC = schema.minContains !== undefined ? schema.minContains : 1
     const maxC = schema.maxContains !== undefined ? schema.maxContains : Infinity
@@ -2314,7 +2367,7 @@ function genCode(schema, v, lines, ctx, knownType) {
   }
 
   // not
-  if (schema.not) {
+  if (schema.not !== undefined) {
     const subLines = []
     genCode(schema.not, '_nv', subLines, ctx)
     if (subLines.length === 0) {
@@ -2326,7 +2379,7 @@ function genCode(schema, v, lines, ctx, knownType) {
   }
 
   // if/then/else
-  if (schema.if) {
+  if (schema.if !== undefined) {
     const ifLines = []
     genCode(schema.if, '_iv', ifLines, ctx)
     const fi = ctx.varCounter++
@@ -2335,14 +2388,14 @@ function genCode(schema, v, lines, ctx, knownType) {
       : `function(_iv){${ifLines.join(';')};return true}`
 
     let thenFn = 'null', elseFn = 'null'
-    if (schema.then) {
+    if (schema.then !== undefined) {
       const thenLines = []
       genCode(schema.then, '_tv', thenLines, ctx)
       thenFn = thenLines.length === 0
         ? `function(_tv){return true}`
         : `function(_tv){${thenLines.join(';')};return true}`
     }
-    if (schema.else) {
+    if (schema.else !== undefined) {
       const elseLines = []
       genCode(schema.else, '_ev', elseLines, ctx)
       elseFn = elseLines.length === 0
@@ -2846,9 +2899,7 @@ const FORMAT_CODEGEN = {
       ? `{const _at=${v}.indexOf('@');if(_at<=0||_at>=${v}.length-1||${v}.indexOf('.',_at)<=_at+1)return false}`
       : `if(typeof ${v}==='string'){const _at=${v}.indexOf('@');if(_at<=0||_at>=${v}.length-1||${v}.indexOf('.',_at)<=_at+1)return false}`
   },
-  date: (v, isStr) => isStr
-    ? `{if(${v}.length!==10||!/^\\d{4}-\\d{2}-\\d{2}$/.test(${v}))return false;const _dm=+${v}.slice(5,7),_dd=+${v}.slice(8,10);if(_dm<1||_dm>12||_dd<1||_dd>31)return false}`
-    : `if(typeof ${v}==='string'){if(${v}.length!==10||!/^\\d{4}-\\d{2}-\\d{2}$/.test(${v}))return false;const _dm=+${v}.slice(5,7),_dd=+${v}.slice(8,10);if(_dm<1||_dm>12||_dd<1||_dd>31)return false}`,
+  date: _formats.dateSource,
   uuid: (v, isStr) => isStr
     ? `if(${v}.length!==36||!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(${v}))return false`
     : `if(typeof ${v}==='string'&&(${v}.length!==36||!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(${v})))return false`,
@@ -2867,9 +2918,7 @@ const FORMAT_CODEGEN = {
   'uri-reference': (v, isStr) => isStr
     ? `if(/[\\s\\u0000-\\u001f\\u007f]/.test(${v}))return false`
     : `if(typeof ${v}==='string'&&/[\\s\\u0000-\\u001f\\u007f]/.test(${v}))return false`,
-  ipv4: (v, isStr) => isStr
-    ? `{const _p=${v}.split('.');if(_p.length!==4||!_p.every(function(n){var x=+n;return x>=0&&x<=255&&String(x)===n}))return false}`
-    : `if(typeof ${v}==='string'){const _p=${v}.split('.');if(_p.length!==4||!_p.every(function(n){var x=+n;return x>=0&&x<=255&&String(x)===n}))return false}`,
+  ipv4: _formats.ipv4Source,
   ipv6: (v, isStr) => isStr
     ? `{const _s=${v};if(_s===''||!/^[0-9a-fA-F:]+$/.test(_s)||_s.split(':').length<3||_s.split(':').length>8)return false}`
     : `if(typeof ${v}==='string'){const _s=${v};if(_s===''||!/^[0-9a-fA-F:]+$/.test(_s)||_s.split(':').length<3||_s.split(':').length>8)return false}`,
@@ -3032,19 +3081,16 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
   if (!sharedCodegenGate(schema, schemaMap)) return null
   if (schema.patternProperties) {
     for (const [pat, sub] of Object.entries(schema.patternProperties)) {
-      if (typeof sub === 'boolean') return null
       if (/\\[pP]\{/.test(pat)) return null
       if (typeof sub === 'object' && sub !== null && !codegenSafe(sub, schemaMap)) return null
     }
   }
   if (schema.dependentSchemas) {
     for (const sub of Object.values(schema.dependentSchemas)) {
-      if (typeof sub === 'boolean') return null
       if (typeof sub === 'object' && sub !== null && !codegenSafe(sub, schemaMap)) return null
     }
   }
   if (schema.propertyNames) {
-    if (typeof schema.propertyNames === 'boolean') return null
     const pn = schema.propertyNames
     const supported = ['maxLength', 'minLength', 'pattern', 'const', 'enum']
     const keys = Object.keys(pn).filter(k => k !== '$schema')
@@ -3145,6 +3191,10 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
     const subSp = branchSp + '/' + i
     if (typeof sub === 'object' && sub !== null) {
       genCodeE(sub, '_bv', pathExpr, subLines, ctx, subSp)
+    } else if (sub === false) {
+      // A false branch never matches; it reports the same error the
+      // interpreter attaches to a false schema.
+      subLines.push(`_e.push({keyword:'not',instancePath:${pathExpr||'""'},schemaPath:'${subSp}',params:{},message:'boolean schema is false'})`)
     }
     const title = (sub && typeof sub === 'object' && typeof sub.title === 'string') ? sub.title : ''
     titles.push(title)
@@ -3166,6 +3216,16 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
 // `_all` parameter: if falsy, return after first error.
 function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (!schemaPrefix) schemaPrefix = '#'
+  // A false schema reports one error at the value that reached it, with the
+  // keyword the interpreter has always used for it, `not` (lib/plan-compiler.js
+  // line 58; its `err()` discards the 'false schema' label). Other validators
+  // name this keyword `false schema`; changing it here would change output
+  // the interpreter path already produces, so both engines say `not`.
+  if (schema === false) {
+    lines.push(`;_e.push({keyword:'not',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}',params:{},message:'boolean schema is false'});if(!_all)return{valid:false,errors:_e}`)
+    return
+  }
+  if (schema === true) return
   if (typeof schema !== 'object' || schema === null) return
   if (!ctx.regExpMap) {
     ctx.regExpMap = new Map();
@@ -3176,9 +3236,26 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (schema.$ref === '#') return
     const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
     if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
+      const defName = m[1]
+      if (!ctx.cyclicDefs) ctx.cyclicDefs = cyclicDefNames(ctx.rootDefs)
+      if (ctx.cyclicDefs.has(defName)) {
+        // Named helper for a def on a cycle; the path comes in as an
+        // argument because every call site has its own.
+        if (!ctx.defFns) ctx.defFns = new Map()
+        let fnName = ctx.defFns.get(defName)
+        if (!fnName) {
+          fnName = '_defE' + ctx.defFns.size + '_' + defName.replace(/[^A-Za-z0-9_]/g, '_')
+          ctx.defFns.set(defName, fnName)
+          const bodyLines = []
+          genCodeE(ctx.rootDefs[defName], 'd', '_p', bodyLines, ctx, '#/$defs/' + defName)
+          ctx.helperCode.push(`function ${fnName}(d,_p,_all,_e){${bodyLines.join('\n  ')}}`)
+        }
+        lines.push(`${fnName}(${v},${pathExpr || '""'},_all,_e);if(!_all&&_e.length)return{valid:false,errors:_e}`)
+        return
+      }
       if (ctx.refStack.has(schema.$ref)) return
       ctx.refStack.add(schema.$ref)
-      genCodeE(ctx.rootDefs[m[1]], v, pathExpr, lines, ctx, schemaPrefix)
+      genCodeE(ctx.rootDefs[defName], v, pathExpr, lines, ctx, schemaPrefix)
       ctx.refStack.delete(schema.$ref)
       return
     }
@@ -3496,7 +3573,26 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const ki = ctx.varCounter++
     const known = Object.keys(schema.properties || {})
     const guard = known.length ? `const _ak${ki}=new Set([${known.map((k) => JSON.stringify(k)).join(',')}]);` : ''
-    const keep = known.length ? `if(!_ak${ki}.has(_k${ki})){` : `{`
+    // A key matched by any patternProperties entry is not additional.
+    const patTests = []
+    for (const pat of Object.keys(schema.patternProperties || {})) {
+      const pattern = JSON.stringify(pat)
+      if (!ctx.regExpMap.has(pattern)) {
+        const ri = ctx.varCounter++
+        ctx.regExpMap.set(pattern, ri)
+        if (patternIsSafe(pat)) {
+          ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`)
+          ctx.usesSafeRe = true
+        } else {
+          ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`)
+        }
+      }
+      patTests.push(`_re${ctx.regExpMap.get(pattern)}.test(_k${ki})`)
+    }
+    const conds = []
+    if (known.length) conds.push(`!_ak${ki}.has(_k${ki})`)
+    if (patTests.length) conds.push(`!(${patTests.join('||')})`)
+    const keep = conds.length ? `if(${conds.join('&&')}){` : `{`
     lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${guard}for(const _k${ki} in ${v}){${keep}`)
     const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
     genCodeE(schema.additionalProperties, `${v}[_k${ki}]`, p, lines, ctx, schemaPrefix + '/additionalProperties')
@@ -3512,6 +3608,14 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     }
   }
 
+  // propertyNames: false reports every key, at the key's own path, the way the
+  // interpreter does (plan-compiler: instancePath + '/' + key).
+  if (schema.propertyNames === false) {
+    const ki = ctx.varCounter++
+    const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
+    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){_e.push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames',params:{},message:'boolean schema is false'});if(!_all)return{valid:false,errors:_e}}}`)
+  }
+
   // propertyNames
   if (schema.propertyNames && typeof schema.propertyNames === 'object') {
     const pn = schema.propertyNames
@@ -3550,7 +3654,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 
   // items — starts after prefixItems (Draft 2020-12 semantics)
-  if (schema.items) {
+  if (schema.items !== undefined && schema.items !== true) {
     const startIdx = schema.prefixItems ? schema.prefixItems.length : 0
     const idx = `_j${ctx.varCounter}`
     const elem = `_ei${ctx.varCounter}`
@@ -3572,7 +3676,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 
   // contains
-  if (schema.contains) {
+  if (schema.contains !== undefined) {
     const ci = ctx.varCounter++
     const subLines = []
     genCode(schema.contains, `_cv`, subLines, ctx)
@@ -3605,7 +3709,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 
   // not
-  if (schema.not) {
+  if (schema.not !== undefined) {
     const subLines = []
     genCode(schema.not, '_nv', subLines, ctx)
     const nfn = subLines.length === 0 ? `function(_nv){return true}` : `function(_nv){${subLines.join(';')};return true}`
@@ -3614,7 +3718,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 
   // if/then/else
-  if (schema.if) {
+  if (schema.if !== undefined) {
     const ifLines = []
     genCode(schema.if, '_iv', ifLines, ctx)
     const fi = ctx.varCounter++
@@ -3622,13 +3726,13 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       ? `function(_iv){return true}`
       : `function(_iv){${ifLines.join(';')};return true}`
     lines.push(`{const _if${fi}=${ifFn}`)
-    if (schema.then) {
+    if (schema.then !== undefined) {
       lines.push(`if(_if${fi}(${v})){`)
       genCodeE(schema.then, v, pathExpr, lines, ctx, schemaPrefix+'/then')
       lines.push(`}`)
     }
-    if (schema.else) {
-      lines.push(`${schema.then ? 'else' : `if(!_if${fi}(${v}))`}{`)
+    if (schema.else !== undefined) {
+      lines.push(`${schema.then !== undefined ? 'else' : `if(!_if${fi}(${v}))`}{`)
       genCodeE(schema.else, v, pathExpr, lines, ctx, schemaPrefix+'/else')
       lines.push(`}`)
     }
@@ -3647,6 +3751,10 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
     if (s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) return null
     // Bail on self-referencing schemas — combined codegen doesn't support recursion
     if (s.includes('"$ref":"#"')) return null
+    // Defs on a $ref cycle compile as named functions in the boolean and
+    // errors generators; this generator has no preamble for them, so it
+    // declines and the router uses the errors generator.
+    if (cyclicDefNames(schema.$defs || schema.definitions).size) return null
     // Bail on additionalProperties as a schema — combined path doesn't emit the
     // per-key sub-schema loop yet. The jsFn + errFn fallback handles it correctly.
     if (hasAdditionalPropertiesSchema(schema)) return null
@@ -3665,19 +3773,16 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
   if (!sharedCodegenGate(schema, schemaMap)) return null
   if (schema.patternProperties) {
     for (const [pat, sub] of Object.entries(schema.patternProperties)) {
-      if (typeof sub === 'boolean') return null
       if (/\\[pP]\{/.test(pat)) return null
       if (typeof sub === 'object' && sub !== null && !codegenSafe(sub, schemaMap)) return null
     }
   }
   if (schema.dependentSchemas) {
     for (const sub of Object.values(schema.dependentSchemas)) {
-      if (typeof sub === 'boolean') return null
       if (typeof sub === 'object' && sub !== null && !codegenSafe(sub, schemaMap)) return null
     }
   }
   if (schema.propertyNames) {
-    if (typeof schema.propertyNames === 'boolean') return null
     const pn = schema.propertyNames
     const supported = ['maxLength', 'minLength', 'pattern', 'const', 'enum']
     const keys = Object.keys(pn).filter(k => k !== '$schema')
@@ -3747,6 +3852,13 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
 // If type check fails → push error, skip property checks (they'd crash).
 function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (!schemaPrefix) schemaPrefix = '#'
+  if (schema === false) {
+    // Leading semicolon: the previous generated line may end in an
+    // expression, and a line starting with `(` would be parsed as a call.
+    lines.push(`;(_e||(_e=[])).push({keyword:'not',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}',params:{},message:'boolean schema is false'})`)
+    return
+  }
+  if (schema === true) return
   if (typeof schema !== 'object' || schema === null) return
 
   // $ref — resolve local, anchor, and cross-schema refs
@@ -4181,6 +4293,12 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     }
   }
 
+  if (schema.propertyNames === false) {
+    const ki = ctx.varCounter++
+    const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
+    lines.push(`;if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){(_e||(_e=[])).push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames',params:{},message:'boolean schema is false'})}}`)
+  }
+
   // propertyNames — skip if already merged into patternProperties loop
   if (schema.propertyNames && typeof schema.propertyNames === 'object' && !ctx._ppHandledPropertyNamesC) {
     const pn = schema.propertyNames
@@ -4211,7 +4329,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 
   // items
-  if (schema.items) {
+  if (schema.items !== undefined && schema.items !== true) {
     const startIdx = schema.prefixItems ? schema.prefixItems.length : 0
     const idx = `_j${ctx.varCounter}`, elem = `_ei${ctx.varCounter}`
     ctx.varCounter++
@@ -4232,7 +4350,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 
   // contains
-  if (schema.contains) {
+  if (schema.contains !== undefined) {
     const ci = ctx.varCounter++
     const subLines = []
     genCode(schema.contains, `_cv`, subLines, ctx)
@@ -4263,7 +4381,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 
   // not
-  if (schema.not) {
+  if (schema.not !== undefined) {
     const sl = []; genCode(schema.not, '_nv', sl, ctx)
     const nfn = sl.length === 0 ? `function(_nv){return true}` : `function(_nv){${sl.join(';')};return true}`
     const fi = ctx.varCounter++
@@ -4271,13 +4389,13 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 
   // if/then/else
-  if (schema.if) {
+  if (schema.if !== undefined) {
     const sl = []; genCode(schema.if, '_iv', sl, ctx)
     const fi = ctx.varCounter++
     const ifFn = sl.length === 0 ? `function(_iv){return true}` : `function(_iv){${sl.join(';')};return true}`
     lines.push(`{const _if${fi}=${ifFn}`)
-    if (schema.then) { lines.push(`if(_if${fi}(${v})){`); genCodeC(schema.then, v, pathExpr, lines, ctx, schemaPrefix+'/then'); lines.push(`}`) }
-    if (schema.else) { lines.push(`${schema.then ? 'else' : `if(!_if${fi}(${v}))`}{`); genCodeC(schema.else, v, pathExpr, lines, ctx, schemaPrefix+'/else'); lines.push(`}`) }
+    if (schema.then !== undefined) { lines.push(`if(_if${fi}(${v})){`); genCodeC(schema.then, v, pathExpr, lines, ctx, schemaPrefix+'/then'); lines.push(`}`) }
+    if (schema.else !== undefined) { lines.push(`${schema.then !== undefined ? 'else' : `if(!_if${fi}(${v}))`}{`); genCodeC(schema.else, v, pathExpr, lines, ctx, schemaPrefix+'/else'); lines.push(`}`) }
     lines.push(`}`)
   }
 
@@ -4362,7 +4480,7 @@ function _collectEval(schema, result, defs, schemaMap, refStack, isRoot) {
 
   // contains: marks matching items as evaluated (not ALL items)
   // Always set dynamic since which items match depends on the data
-  if (schema.contains) {
+  if (schema.contains !== undefined) {
     result.dynamic = true
   }
 

package/lib/version.js

@@ -7,4 +7,4 @@
 //
 // Kept in lockstep with package.json by `tests/test_version_sync.js`.
 
-module.exports = '1.9.0';
+module.exports = '1.10.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "JSON Schema validation with first-class TypeScript and zero runtime cost. AOT compile to per-schema ESM modules with zero validator dependency. Generic Validator<T> for TypeBox/Zod/Valibot composition. Optional runtime API. Standard Schema V1 compatible.",
   "main": "index.js",
   "module": "index.mjs",
@@ -44,7 +44,7 @@
     "release:check": "node scripts/regen-safe-regex-source.js && node tests/test_pack_purity.js && node scripts/check-doc-coverage.js && node tests/test_error_codes_lock.js && node tests/test_safe_regex_source_sync.js && node tests/test_version_sync.js",
     "build": "cmake-js build --target ata",
     "rebuild": "cmake-js rebuild --target ata",
-    "test": "node test.js && node tests/test_removed_aot_methods.js && node tests/test_no_native.js && node tests/test_no_eval.js && node tests/test_property_dependencies.js && node tests/test_v1_dialect.js && node tests/test_buffer_path_parity.js && node tests/test_buffer_gate.js && node tests/test_draft7_semantics.js && node tests/test_metaschema_ref.js && node tests/test_pure_js_unsupported.js && node tests/test_native_load_order.js && node tests/test_pack_purity.js && node tests/test_make_native_package.js && node tests/test_browser_nofs.js && node tests/test_browser_imports_guard.js && node tests/test_version_sync.js && node tests/test_native_loaded.js && node tests/test_safe_regex_source_sync.js && node tests/test_t_builder.js && node tests/test_async_refine.js && node tests/test_safe_regex.js && node tests/test_safe_regex_integration.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_standalone_formats.js && node tests/test_aot_format_mode.js && node tests/test_aot_additional_props_errors.js && node tests/test_id_anchor_refs.js && node tests/test_engine_routing.js && node tests/test_engine_diagnostic.js && node tests/test_format_engine_parity.js && node tests/test_defs_pointer_alias.js && node tests/test_cross_doc_root_ref.js && node tests/test_codegen_entrypoint_agreement.js && node tests/test_hybrid_agreement.js && node tests/test_ajv_errors.js && node tests/test_pattern_properties_errors.js && node tests/test_no_input_mutation.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_error_code_lookup.js && node tests/test_error_order.js && node tests/test_value_equality.js && node tests/test_vocabulary.js && node tests/test_schema_scan.js && node tests/test_lazy_errors.js && node tests/test_plan_compiler.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_enrich_received.js && node tests/test_rich_errors_optout.js && node tests/test_error_messages.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_data_positions.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_additive_fields.js && node tests/test_diagnostic_source.js && node tests/test_diagnose.js && node tests/test_correlate.js && node tests/test_diagnostics_score.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node tests/test_cli_version.js && node benchmark/bench_aot_size.mjs",
+    "test": "node test.js && node tests/test_removed_aot_methods.js && node tests/test_no_native.js && node tests/test_no_eval.js && node tests/test_property_dependencies.js && node tests/test_v1_dialect.js && node tests/test_buffer_path_parity.js && node tests/test_buffer_gate.js && node tests/test_draft7_semantics.js && node tests/test_metaschema_ref.js && node tests/test_pure_js_unsupported.js && node tests/test_native_load_order.js && node tests/test_pack_purity.js && node tests/test_make_native_package.js && node tests/test_browser_nofs.js && node tests/test_browser_imports_guard.js && node tests/test_version_sync.js && node tests/test_native_loaded.js && node tests/test_safe_regex_source_sync.js && node tests/test_t_builder.js && node tests/test_async_refine.js && node tests/test_safe_regex.js && node tests/test_safe_regex_integration.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_standalone_formats.js && node tests/test_aot_format_mode.js && node tests/test_aot_additional_props_errors.js && node tests/test_id_anchor_refs.js && node tests/test_engine_routing.js && node tests/test_engine_diagnostic.js && node tests/test_format_engine_parity.js && node tests/test_formats_single_pass.js && node tests/test_defs_pointer_alias.js && node tests/test_cross_doc_root_ref.js && node tests/test_codegen_entrypoint_agreement.js && node tests/test_hybrid_agreement.js && node tests/test_codegen_edge_shapes.js && node tests/test_ajv_errors.js && node tests/test_pattern_properties_errors.js && node tests/test_no_input_mutation.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_error_code_lookup.js && node tests/test_error_order.js && node tests/test_value_equality.js && node tests/test_vocabulary.js && node tests/test_schema_scan.js && node tests/test_lazy_errors.js && node tests/test_plan_compiler.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_enrich_received.js && node tests/test_rich_errors_optout.js && node tests/test_error_messages.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_data_positions.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_additive_fields.js && node tests/test_diagnostic_source.js && node tests/test_diagnose.js && node tests/test_correlate.js && node tests/test_diagnostics_score.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node tests/test_cli_version.js && node benchmark/bench_aot_size.mjs",
     "bench:size": "node benchmark/bench_aot_size.mjs",
     "test:suite": "node tests/run_suite.js && node tests/run_suite.js draft7 && node tests/run_suite.js v1",
     "test:compat": "node tests/test_compat.js",
@@ -112,13 +112,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.9.0",
-    "@ata-validator/native-darwin-x64": "1.9.0",
-    "@ata-validator/native-linux-x64-gnu": "1.9.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.9.0",
-    "@ata-validator/native-linux-x64-musl": "1.9.0",
-    "@ata-validator/native-linux-arm64-musl": "1.9.0",
-    "@ata-validator/native-win32-x64": "1.9.0"
+    "@ata-validator/native-darwin-arm64": "1.10.0",
+    "@ata-validator/native-darwin-x64": "1.10.0",
+    "@ata-validator/native-linux-x64-gnu": "1.10.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.10.0",
+    "@ata-validator/native-linux-x64-musl": "1.10.0",
+    "@ata-validator/native-linux-arm64-musl": "1.10.0",
+    "@ata-validator/native-win32-x64": "1.10.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"