ata-validator 1.9.0 → 1.11.0

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,12 +758,13 @@ 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 }) },
-  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),
+  ipv4: _formats.ipv4,
+  hostname: _formats.hostname,
 }
 
 // Dangerous JS property names that exist on Object.prototype
@@ -842,6 +845,94 @@ 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.
+// Data can point back at itself, and a schema that references itself would
+// then recurse until the stack runs out. Validation runs in two passes: the
+// fast one counts depth and gives up past CYCLE_DEPTH, the second re-runs with
+// a set of the values currently under check, where a value met twice is a
+// fixed point and counts as satisfied. That is what the interpreted engine
+// does, so both engines answer the same on cyclic input. Legitimate documents
+// never reach the threshold, so they only pay the counter.
+// Raised by a generator that meets a construct it cannot express. The entry
+// point turns it into a decline, so the caller falls back to an engine that
+// can. Emitting nothing would mean "everything is valid", which is the failure
+// mode this project has shipped three times in $ref handling; declining is the
+// only safe way out.
+const DECLINE = Symbol('ata.decline')
+
+const CYCLE_DEPTH = 512
+
+// Declarations the guarded functions close over. Emitted once, ahead of them.
+function emitGuardState () {
+  return 'const _CYC={};const _stk=new Set();let _sd=0,_sg=false\n  '
+}
+
+// Wraps a self-recursive root: `name` is the guarded entry, `name`_b the body.
+function emitRootGuard (name, args, onRepeat) {
+  const call = `${name}_b(${args})`
+  return (
+    `function ${name}(${args}){\n  ` +
+    `if(_sg){if(typeof d!=='object'||d===null)return ${call};if(_stk.has(d))return ${onRepeat};_stk.add(d);try{return ${call}}finally{_stk.delete(d)}}\n  ` +
+    `if(++_sd>${CYCLE_DEPTH})throw _CYC\n  const _r=${call}\n  _sd--\n  return _r\n  }\n  `
+  )
+}
+
+// Runs `attempt`, and on the depth signal runs it again under the guard.
+// `reset` clears anything the abandoned pass left behind.
+function emitGuardedRun (attempt, reset, defSets) {
+  const clears = ['_stk.clear()'].concat(defSets.map((n) => `${n}_s.clear()`)).join(';')
+  return (
+    `_sd=0\n  try{${attempt}}catch(_err){\n  ` +
+    `if(_err!==_CYC)throw _err\n  ` +
+    `${reset}_sg=true;${clears}\n  ` +
+    `try{${attempt}}finally{_sg=false}\n  }\n  `
+  )
+}
+
+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 +946,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 +1016,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 +1059,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 +1077,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 +1091,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 +1379,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 +1386,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')
@@ -1414,18 +1460,33 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
     }
   }
 
+  const defSets = ctx.defFns ? Array.from(ctx.defFns.values()) : []
+  const needsGuard = ctx.usesRecursion || defSets.length > 0
+
   let body, hybridBody
   if (ctx.usesRecursion) {
-    // Self-recursive: wrap in named function
-    body = `function _validate(d){\n  ${checkStr}\n  return true\n  }\n  return _validate(d)`
-    // Hybrid: keep _validate as boolean, wrap only the outer call
-    hybridBody = `function _validate(d){\n  ${checkStr}\n  return true\n  }\n  return _validate(d)?R:E(d)`
+    // Self-recursive: a named body reached through the cycle guard, so data
+    // that points back at itself settles instead of exhausting the stack.
+    const decl = emitRootGuard('_validate', 'd', 'true') +
+      `function _validate_b(d){\n  ${checkStr}\n  return true\n  }\n  `
+    const run = emitGuardedRun('return _validate(d)', '', defSets)
+    body = `${decl}function _run(d){\n  ${run}\n  }\n  return _run(d)`
+    // Hybrid: keep the boolean answer, wrap only the outer call
+    hybridBody = `${decl}function _run(d){\n  ${run}\n  }\n  return _run(d)?R:E(d)`
+  } else if (defSets.length > 0) {
+    // No self-reference at the root, but a def on a cycle can still be
+    // re-entered with the same value; the guarded functions need their state.
+    const run = emitGuardedRun(`return _body(d)`, '', defSets)
+    body = `function _body(d){\n  ${checkStr}\n  return true\n  }\n  function _run(d){\n  ${run}\n  }\n  return _run(d)`
+    hybridBody = `function _body(d){\n  ${checkStr}\n  return true\n  }\n  function _run(d){\n  ${run}\n  }\n  return _run(d)?R:E(d)`
   } else {
     body = checkStr + '\n  return true'
     hybridBody = replaceTopLevel(checkStr + '\n  return R')
   }
 
-  const preambleStr = ctx.preamble && ctx.preamble.length ? ctx.preamble.join('\n  ') + '\n  ' : ''
+  const guardStr = needsGuard ? emitGuardState() : ''
+  const preambleStr = guardStr +
+    (ctx.preamble && ctx.preamble.length ? ctx.preamble.join('\n  ') + '\n  ' : '')
 
   try {
     let boolFn
@@ -1654,6 +1715,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 +1739,37 @@ 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)
+          // Entered through the cycle guard: see emitGuardState. In the fast
+          // pass the wrapper only counts depth; the set is used by the second,
+          // guarded pass that runs when data turns out to point back at
+          // itself.
+          ctx.preamble.push(
+            `const ${fnName}_s=new Set()\n  function ${fnName}(d){\n  ` +
+              `if(_sg){if(typeof d!=='object'||d===null)return ${fnName}_b(d);if(${fnName}_s.has(d))return true;${fnName}_s.add(d);try{return ${fnName}_b(d)}finally{${fnName}_s.delete(d)}}\n  ` +
+              `if(++_sd>${CYCLE_DEPTH})throw _CYC\n  const _r=${fnName}_b(d)\n  _sd--\n  return _r\n  }\n  ` +
+              `function ${fnName}_b(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 +2141,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 +2182,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 +2252,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 +2327,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 +2354,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 +2434,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 +2446,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 +2455,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,15 +2966,11 @@ 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`,
-  'date-time': (v, isStr) => isStr
-    ? `if(!/^\\d{4}-\\d{2}-\\d{2}[Tt]\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?([Zz]|[+-]\\d{2}:\\d{2})$/.test(${v})||isNaN(Date.parse(${v})))return false`
-    : `if(typeof ${v}==='string'&&(!/^\\d{4}-\\d{2}-\\d{2}[Tt]\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?([Zz]|[+-]\\d{2}:\\d{2})$/.test(${v})||isNaN(Date.parse(${v}))))return false`,
+  'date-time': _formats.dateTimeSource,
   time: (v, isStr) => isStr
     ? `if(!/^([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})?$/.test(${v}))return false`
     : `if(typeof ${v}==='string'&&!/^([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})?$/.test(${v}))return false`,
@@ -2867,15 +2983,9 @@ 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}`,
-  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}`,
-  hostname: (v, isStr) => isStr
-    ? `if(!/^[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(${v}))return false`
-    : `if(typeof ${v}==='string'&&!/^[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(${v}))return false`,
+  ipv4: _formats.ipv4Source,
+  ipv6: _formats.ipv6Source,
+  hostname: _formats.hostnameSource,
 }
 
 // Safe key escaping: use JSON.stringify to handle all special chars (newlines, null bytes, etc.)
@@ -3020,8 +3130,6 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
   if (typeof schema === 'object' && schema !== null) {
     const s = JSON.stringify(schema)
     if (s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) return null
-    // Bail on self-referencing schemas — error codegen doesn't support recursion
-    if (s.includes('"$ref":"#"')) return null
   }
   if (typeof schema === 'boolean') {
     return schema
@@ -3032,19 +3140,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')
@@ -3087,7 +3192,12 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
                   : null }
   ctx.helperCode.push('const _cpLen=s=>{let n=0;for(const _ of s)n++;return n}')
   const lines = []
-  genCodeE(schema, 'd', '', lines, ctx, '#')
+  try {
+    genCodeE(schema, 'd', '', lines, ctx, '#')
+  } catch (e) {
+    if (e === DECLINE) return null
+    throw e
+  }
   // Inline branch-collapse helper only when the schema actually used a
   // oneOf/anyOf branch path (tracked via ctx.usesBranchCollapse). Keeps the
   // AOT output small for schemas that don't compose. Standalone modules can't
@@ -3098,16 +3208,28 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
   if (lines.length === 0) return (d) => ({ valid: true, errors: [] })
 
   const checkStr = lines.join('\n  ')
+  const defSetsE = ctx.defFns ? Array.from(ctx.defFns.values()) : []
+  const needsGuardE = ctx.usesRecursion || defSetsE.length > 0
+  const guardStrE = needsGuardE ? emitGuardState() : ''
+  const helpersE = ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : ''
+
   let body
   if (ctx.usesRecursion) {
-    body = `const _e=[];\n  ` +
-      (ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : '') +
-      `function _validateE(d,_all,_e){\n  ${checkStr}\n  }\n  _validateE(d,_all,_e);\n  ` +
+    // The abandoned first pass may have pushed errors, so the retry starts
+    // from an empty list and the reported errors come from the guarded run
+    // alone.
+    body = `const _e=[];\n  ` + guardStrE + helpersE +
+      emitRootGuard('_validateE', 'd,_all,_e', '') +
+      `function _validateE_b(d,_all,_e){\n  ${checkStr}\n  }\n  ` +
+      emitGuardedRun('_validateE(d,_all,_e)', '_e.length=0;', defSetsE) +
+      `return{valid:_e.length===0,errors:_e}`
+  } else if (defSetsE.length > 0) {
+    body = `const _e=[];\n  ` + guardStrE + helpersE +
+      `function _bodyE(d,_all,_e){\n  ${checkStr}\n  }\n  ` +
+      emitGuardedRun('_bodyE(d,_all,_e)', '_e.length=0;', defSetsE) +
       `return{valid:_e.length===0,errors:_e}`
   } else {
-    body = `const _e=[];\n  ` +
-      (ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : '') +
-      checkStr +
+    body = `const _e=[];\n  ` + helpersE + checkStr +
       `\n  return{valid:_e.length===0,errors:_e}`
   }
   try {
@@ -3145,6 +3267,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,19 +3292,54 @@ 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();
   }
   // $ref — resolve local and cross-schema refs
   if (schema.$ref) {
-    // Self-reference "#" — no-op (permissive) to avoid infinite recursion
-    if (schema.$ref === '#') return
+    // A self-reference cannot be expressed here yet: the root helper takes no
+    // path argument, so errors raised through it would carry the path of the
+    // root rather than of the value that failed. This used to fall through as
+    // a permissive no-op, which accepted whatever the reference guarded.
+    if (schema.$ref === '#') throw DECLINE
     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(
+            `const ${fnName}_s=new Set()\n  function ${fnName}(d,_p,_all,_e){\n  ` +
+              `if(_sg){if(typeof d!=='object'||d===null)return ${fnName}_b(d,_p,_all,_e);if(${fnName}_s.has(d))return;${fnName}_s.add(d);try{return ${fnName}_b(d,_p,_all,_e)}finally{${fnName}_s.delete(d)}}\n  ` +
+              `if(++_sd>${CYCLE_DEPTH})throw _CYC\n  const _r=${fnName}_b(d,_p,_all,_e)\n  _sd--\n  return _r\n  }\n  ` +
+              `function ${fnName}_b(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 +3657,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 +3692,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 +3738,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 +3760,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 +3793,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 +3802,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 +3810,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 +3835,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 +3857,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 +3936,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 +4377,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 +4413,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 +4434,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 +4465,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 +4473,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 +4564,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
   }