ata-validator 0.7.3 → 0.9.0

package/lib/js-compiler.js

@@ -39,7 +39,11 @@ function compileToJS(schema, defs, schemaMap) {
   if (typeof schema !== 'object' || schema === null) return null
 
   // Bail if schema has edge cases that JS fast path gets wrong
-  if (!defs && !codegenSafe(schema, schemaMap)) return null
+  // Exception: $dynamicRef/$anchor are handled by the interpretive path even though codegen can't
+  if (!defs && !codegenSafe(schema, schemaMap)) {
+    const str = JSON.stringify(schema)
+    if (!str.includes('"$dynamicRef"') && !str.includes('"$dynamicAnchor"') && !str.includes('"$anchor"')) return null
+  }
 
   // Collect $defs early so sub-schemas can resolve $ref
   const rootDefs = defs || collectDefs(schema)
@@ -60,6 +64,23 @@ function compileToJS(schema, defs, schemaMap) {
     checks.push(refFn)
   }
 
+  // $dynamicRef — resolve via anchor defs or JSON pointer
+  if (schema.$dynamicRef) {
+    const ref = schema.$dynamicRef
+    const anchorName = ref.startsWith('#') ? ref : '#' + ref
+    if (rootDefs && rootDefs[anchorName]) {
+      const entry = rootDefs[anchorName]
+      checks.push((d) => { const fn = entry.fn; return fn ? fn(d) : true })
+    } else {
+      // JSON pointer: "#/$defs/foo" or "#/definitions/foo"
+      const m = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
+      if (m && rootDefs && rootDefs[m[1]]) {
+        const entry = rootDefs[m[1]]
+        checks.push((d) => { const fn = entry.fn; return fn ? fn(d) : true })
+      }
+    }
+  }
+
   // type
   if (schema.type) {
     const types = Array.isArray(schema.type) ? schema.type : [schema.type]
@@ -395,12 +416,75 @@ function collectDefs(schema) {
         },
         raw: def
       }
+      // Register anchors
+      if (def && typeof def === 'object') {
+        if (def.$anchor) {
+          const anchorDef = def
+          let anchorCached = undefined
+          defs['#' + def.$anchor] = {
+            get fn() {
+              if (anchorCached === undefined) {
+                anchorCached = null
+                anchorCached = compileToJS(anchorDef, defs)
+              }
+              return anchorCached || (() => true)
+            },
+            raw: anchorDef
+          }
+        }
+        if (def.$dynamicAnchor) {
+          const daDef = def
+          let daCached = undefined
+          defs['#' + def.$dynamicAnchor] = {
+            get fn() {
+              if (daCached === undefined) {
+                daCached = null
+                daCached = compileToJS(daDef, defs)
+              }
+              return daCached || (() => true)
+            },
+            raw: daDef
+          }
+        }
+      }
+    }
+  }
+  // Register root-level $anchor/$dynamicAnchor (self-referencing schemas)
+  if (schema.$anchor && !defs['#' + schema.$anchor]) {
+    const rootAnchorSchema = schema
+    let rootACached = undefined
+    defs['#' + schema.$anchor] = {
+      get fn() {
+        if (rootACached === undefined) {
+          rootACached = null
+          rootACached = compileToJS(rootAnchorSchema, defs)
+        }
+        return rootACached || (() => true)
+      },
+      raw: rootAnchorSchema
+    }
+  }
+  if (schema.$dynamicAnchor && !defs['#' + schema.$dynamicAnchor]) {
+    const rootDASchema = schema
+    let rootDACached = undefined
+    defs['#' + schema.$dynamicAnchor] = {
+      get fn() {
+        if (rootDACached === undefined) {
+          rootDACached = null
+          rootDACached = compileToJS(rootDASchema, defs)
+        }
+        return rootDACached || (() => true)
+      },
+      raw: rootDASchema
     }
   }
   return defs
 }
 
 function resolveRef(ref, defs, schemaMap) {
+  // Self-reference: "#" — treat as permissive to avoid infinite recursion
+  if (ref === '#') return () => true
+
   // 1. Local ref
   if (defs) {
     const m = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
@@ -409,13 +493,28 @@ function resolveRef(ref, defs, schemaMap) {
       const entry = defs[name]
       if (entry) return (d) => { const fn = entry.fn; return fn ? fn(d) : true }
     }
+    // Anchor ref: "#foo"
+    if (ref.startsWith('#') && !ref.startsWith('#/')) {
+      const entry = defs[ref]
+      if (entry) return (d) => { const fn = entry.fn; return fn ? fn(d) : true }
+    }
   }
-  // 2. Cross-schema ref
+  // 2. Cross-schema ref (exact match)
   if (schemaMap && schemaMap.has(ref)) {
     const resolved = schemaMap.get(ref)
     const fn = compileToJS(resolved, null, schemaMap)
     return fn || (() => true)
   }
+  // 3. Cross-schema ref (relative URI resolution)
+  if (schemaMap && !ref.includes('://') && !ref.startsWith('#')) {
+    for (const [id] of schemaMap) {
+      if (id.endsWith('/' + ref)) {
+        const resolved = schemaMap.get(id)
+        const fn = compileToJS(resolved, null, schemaMap)
+        return fn || (() => true)
+      }
+    }
+  }
   return null
 }
 
@@ -444,7 +543,7 @@ const TYPE_CHECKS = {
 
 const FORMAT_CHECKS = {
   email: (s) => { const at = s.indexOf('@'); return at > 0 && at < s.length - 1 && s.indexOf('.', at) > at + 1 },
-  date: (s) => s.length === 10 && /^\d{4}-\d{2}-\d{2}$/.test(s),
+  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 },
   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),
@@ -454,12 +553,49 @@ const FORMAT_CHECKS = {
 const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'toString', 'valueOf',
   'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString'])
 
+// Check if all $dynamicRef in a target schema can be resolved via the calling schema's anchors.
+function canResolveDynamicRefs(target, callingSchema, schemaMap) {
+  // Collect anchors from calling schema
+  const anchors = new Set()
+  if (callingSchema.$dynamicAnchor) anchors.add(callingSchema.$dynamicAnchor)
+  const defs = callingSchema.$defs || callingSchema.definitions
+  if (defs) {
+    for (const def of Object.values(defs)) {
+      if (def && typeof def === 'object' && def.$dynamicAnchor) anchors.add(def.$dynamicAnchor)
+    }
+  }
+  // Also collect from schemaMap
+  if (schemaMap) {
+    for (const ext of schemaMap.values()) {
+      if (ext && typeof ext === 'object' && ext.$dynamicAnchor) anchors.add(ext.$dynamicAnchor)
+    }
+  }
+  // Find all $dynamicRef in target
+  const refs = []
+  const findDynRefs = (s) => {
+    if (typeof s !== 'object' || s === null) return
+    if (s.$dynamicRef) {
+      const name = s.$dynamicRef.startsWith('#') ? s.$dynamicRef.slice(1) : s.$dynamicRef
+      refs.push(name)
+    }
+    for (const v of Object.values(s)) {
+      if (Array.isArray(v)) v.forEach(findDynRefs)
+      else if (typeof v === 'object' && v !== null) findDynRefs(v)
+    }
+  }
+  findDynRefs(target)
+  return refs.every(r => anchors.has(r))
+}
+
 // Recursively check if a schema can be safely compiled to JS codegen.
 // Returns false if any sub-schema contains features codegen gets wrong.
 function codegenSafe(schema, schemaMap) {
   if (typeof schema === 'boolean') return true
   if (typeof schema !== 'object' || schema === null) return true
 
+  // Only bail on $dynamicRef if it can't be resolved at compile time
+  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
@@ -490,12 +626,37 @@ function codegenSafe(schema, schemaMap) {
 
   // $ref — allow local refs (#/$defs/Name) and non-local refs if in schemaMap
   if (schema.$ref) {
+    // Self-reference "#" — treated as permissive (no-op) to avoid infinite recursion
+    if (schema.$ref === '#') return true
     const isLocal = /^#\/(?:\$defs|definitions)\/[^/]+$/.test(schema.$ref)
-    const isResolvable = !isLocal && schemaMap && schemaMap.has(schema.$ref)
-    if (!isLocal && !isResolvable) return false
+    let isResolvable = !isLocal && schemaMap && schemaMap.has(schema.$ref)
+    // Relative URI resolution: check if any schemaMap key ends with "/" + ref
+    let resolvedTarget = null
+    if (!isLocal && !isResolvable && schemaMap && !schema.$ref.includes('://') && !schema.$ref.startsWith('#')) {
+      for (const [id] of schemaMap) {
+        if (id.endsWith('/' + schema.$ref)) { isResolvable = true; resolvedTarget = schemaMap.get(id); break }
+      }
+    }
+    // Anchor-style ref: #name (not #/path, not bare #) — resolvable at compile time via anchors map
+    const isAnchorRef = !isLocal && !isResolvable && schema.$ref.length > 1 && schema.$ref.startsWith('#') && !schema.$ref.startsWith('#/')
+    if (!isLocal && !isResolvable && !isAnchorRef) return false
+    // If the resolved target contains $dynamicRef, allow codegen only when:
+    // 1. All $dynamicRefs can be resolved via the current schema's anchors
+    // 2. The resolved target itself is simple enough for codegen (no additionalProperties: false, etc.)
+    if (!resolvedTarget && isResolvable) resolvedTarget = schemaMap.get(schema.$ref)
+    if (resolvedTarget && JSON.stringify(resolvedTarget).includes('"$dynamicRef"')) {
+      const canResolve = canResolveDynamicRefs(resolvedTarget, schema, schemaMap)
+      // Also verify the resolved target doesn't have complex features that codegen can't inline
+      const targetSimple = canResolve && resolvedTarget.additionalProperties === undefined &&
+        !resolvedTarget.patternProperties && !resolvedTarget.dependentSchemas &&
+        !resolvedTarget.propertyNames
+      if (!targetSimple && schema.unevaluatedProperties === undefined && schema.unevaluatedItems === undefined) return false
+    }
     // In Draft 2020-12, $ref with siblings is allowed. Only bail if no unevaluated* keyword
     // (unevaluated schemas need $ref + siblings to work properly)
-    const siblings = Object.keys(schema).filter(k => k !== '$ref' && k !== '$defs' && k !== 'definitions' && k !== '$schema' && k !== '$id')
+    // Schema-organization keywords ($dynamicAnchor, $anchor) are not validation siblings
+    const SCHEMA_ORG_KEYS = new Set(['$ref', '$defs', 'definitions', '$schema', '$id', '$dynamicAnchor', '$anchor'])
+    const siblings = Object.keys(schema).filter(k => !SCHEMA_ORG_KEYS.has(k))
     if (siblings.length > 0 && schema.unevaluatedProperties === undefined && schema.unevaluatedItems === undefined) return false
   }
 
@@ -590,7 +751,31 @@ function compileToJSCodegen(schema, schemaMap) {
     if (keys.some(k => !supported.includes(k))) return null
   }
 
-  const ctx = { varCounter: 0, helpers: [], helperCode: [], closureVars: [], closureVals: [], rootDefs, refStack: new Set(), schemaMap: schemaMap || null }
+  // Build anchors map for $ref/#anchor and $dynamicRef resolution
+  const anchors = {}
+  // Root schema's own $dynamicAnchor / $anchor
+  if (schema.$dynamicAnchor) anchors['#' + schema.$dynamicAnchor] = schema
+  if (schema.$anchor) anchors['#' + schema.$anchor] = schema
+  // Anchors from $defs
+  if (rootDefs) {
+    for (const def of Object.values(rootDefs)) {
+      if (def && typeof def === 'object') {
+        if (def.$dynamicAnchor) anchors['#' + def.$dynamicAnchor] = def
+        if (def.$anchor) anchors['#' + def.$anchor] = def
+      }
+    }
+  }
+  // Anchors from external schemas in schemaMap
+  if (schemaMap) {
+    for (const ext of schemaMap.values()) {
+      if (ext && typeof ext === 'object') {
+        if (ext.$dynamicAnchor && !anchors['#' + ext.$dynamicAnchor]) anchors['#' + ext.$dynamicAnchor] = ext
+        if (ext.$anchor && !anchors['#' + ext.$anchor]) anchors['#' + ext.$anchor] = ext
+      }
+    }
+  }
+
+  const ctx = { varCounter: 0, helpers: [], helperCode: [], closureVars: [], closureVals: [], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: schema }
   const lines = []
   genCode(schema, 'd', lines, ctx)
 
@@ -616,7 +801,16 @@ function compileToJSCodegen(schema, schemaMap) {
     }
   }
 
-  const body = checkStr + '\n  return true'
+  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)`
+  } else {
+    body = checkStr + '\n  return true'
+    hybridBody = replaceTopLevel(checkStr + '\n  return R')
+  }
 
   try {
     let boolFn
@@ -628,7 +822,6 @@ function compileToJSCodegen(schema, schemaMap) {
     }
 
     // Build hybrid: same body, return R instead of true, return E(d) instead of false.
-    const hybridBody = replaceTopLevel(checkStr + '\n  return R')
     try {
       const hybridFactory = new Function(...closureNames, 'R', 'E', `return function(d){${hybridBody}}`)
       boolFn._hybridFactory = (R, E) => hybridFactory(...closureValues, R, E)
@@ -679,6 +872,84 @@ function replaceTopLevel(code) {
   return result
 }
 
+// Returns true if a property sub-schema will generate 2+ lines that each access v,
+// meaning a local variable hoist is worthwhile.
+function needsLocal(schema) {
+  if (typeof schema !== 'object' || schema === null) return false
+  // If it has $ref, allOf, anyOf etc., genCode handles it — don't hoist
+  if (schema.$ref || schema.allOf || schema.anyOf || schema.oneOf || schema.if) return false
+  if (schema.properties || schema.items || schema.prefixItems) return false
+  const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null
+  if (!types || types.length !== 1) return false
+  const t = types[0]
+  let checkCount = 1 // type check itself
+  if (t === 'string') {
+    if (schema.minLength !== undefined) checkCount++
+    if (schema.maxLength !== undefined) checkCount++
+    if (schema.pattern) checkCount++
+    if (schema.format) checkCount++
+  } else if (t === 'integer' || t === 'number') {
+    if (schema.minimum !== undefined) checkCount++
+    if (schema.maximum !== undefined) checkCount++
+    if (schema.exclusiveMinimum !== undefined) checkCount++
+    if (schema.exclusiveMaximum !== undefined) checkCount++
+    if (schema.multipleOf !== undefined) checkCount++
+  }
+  return checkCount >= 2
+}
+
+// Try to generate a single combined check for simple leaf schemas.
+// Returns a string like "{const _v=d["x"];if(typeof _v!=='string'||_v.length<1||_v.length>100)return false}"
+// or null if the schema is too complex.
+function tryGenCombined(schema, access, ctx) {
+  if (typeof schema !== 'object' || schema === null) return null
+  // Only handle simple leaf schemas with a single type and basic constraints
+  if (schema.$ref || schema.allOf || schema.anyOf || schema.oneOf || schema.if) return null
+  if (schema.properties || schema.items || schema.prefixItems || schema.patternProperties) return null
+  if (schema.enum || schema.const !== undefined) return null
+  if (schema.not || schema.dependentRequired || schema.dependentSchemas) return null
+  const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null
+  if (!types || types.length !== 1) return null
+  const t = types[0]
+
+  if (t === 'string') {
+    const conds = [`typeof _v!=='string'`]
+    if (schema.minLength !== undefined) conds.push(`_v.length<${schema.minLength}`)
+    if (schema.maxLength !== undefined) conds.push(`_v.length>${schema.maxLength}`)
+    if (conds.length < 2 && !schema.pattern && !schema.format) return null // not worth combining
+    // pattern and format need separate statements, fall back if present
+    if (schema.pattern || schema.format) return null
+    const vi = ctx.varCounter++
+    return `{const _v=${access};if(${conds.join('||')})return false}`
+  }
+
+  if (t === 'integer') {
+    const conds = [`!Number.isInteger(_v)`]
+    if (schema.minimum !== undefined) conds.push(`_v<${schema.minimum}`)
+    if (schema.maximum !== undefined) conds.push(`_v>${schema.maximum}`)
+    if (schema.exclusiveMinimum !== undefined) conds.push(`_v<=${schema.exclusiveMinimum}`)
+    if (schema.exclusiveMaximum !== undefined) conds.push(`_v>=${schema.exclusiveMaximum}`)
+    if (schema.multipleOf !== undefined) conds.push(`_v%${schema.multipleOf}!==0`)
+    if (conds.length < 2) return null
+    const vi = ctx.varCounter++
+    return `{const _v=${access};if(${conds.join('||')})return false}`
+  }
+
+  if (t === 'number') {
+    const conds = [`typeof _v!=='number'||!isFinite(_v)`]
+    if (schema.minimum !== undefined) conds.push(`_v<${schema.minimum}`)
+    if (schema.maximum !== undefined) conds.push(`_v>${schema.maximum}`)
+    if (schema.exclusiveMinimum !== undefined) conds.push(`_v<=${schema.exclusiveMinimum}`)
+    if (schema.exclusiveMaximum !== undefined) conds.push(`_v>=${schema.exclusiveMaximum}`)
+    if (schema.multipleOf !== undefined) conds.push(`_v%${schema.multipleOf}!==0`)
+    if (conds.length < 2) return null
+    const vi = ctx.varCounter++
+    return `{const _v=${access};if(${conds.join('||')})return false}`
+  }
+
+  return null
+}
+
 // knownType: if parent already verified the type, skip redundant guards.
 // 'object' = we know v is a non-null non-array object
 // 'array'  = we know v is an array
@@ -691,8 +962,14 @@ function genCode(schema, v, lines, ctx, knownType) {
   // Only when THIS schema has unevaluated keywords directly (not via $ref target)
   const hasSiblings = schema.$ref && (schema.unevaluatedProperties !== undefined || schema.unevaluatedItems !== undefined)
   if (schema.$ref) {
+    // Self-reference "#" — recursive call to root validator
+    if (schema.$ref === '#') {
+      ctx.usesRecursion = true
+      lines.push(`if(!_validate(${v}))return false`)
+      if (!hasSiblings) return
+    }
     // 1. Local ref
-    const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
+    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 }
       else {
@@ -701,13 +978,36 @@ function genCode(schema, v, lines, ctx, knownType) {
         ctx.refStack.delete(schema.$ref)
         if (!hasSiblings) return
       }
-    } else if (ctx.schemaMap && ctx.schemaMap.has(schema.$ref)) {
-      // 2. Cross-schema ref
-      if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return }
-      else {
-        ctx.refStack.add(schema.$ref)
-        genCode(ctx.schemaMap.get(schema.$ref), v, lines, ctx, knownType)
-        ctx.refStack.delete(schema.$ref)
+    } else if (schema.$ref !== '#' && !m && schema.$ref.startsWith('#') && !schema.$ref.startsWith('#/')) {
+      // Anchor ref: "#foo" — resolve via rootDefs or anchors map
+      const entry = ctx.rootDefs && ctx.rootDefs[schema.$ref]
+      const anchorTarget = entry && entry.raw ? entry.raw : (ctx.anchors && ctx.anchors[schema.$ref])
+      if (anchorTarget) {
+        if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return }
+        else {
+          ctx.refStack.add(schema.$ref)
+          genCode(anchorTarget, v, lines, ctx, knownType)
+          ctx.refStack.delete(schema.$ref)
+          if (!hasSiblings) return
+        }
+      }
+    } else if (schema.$ref !== '#' && ctx.schemaMap) {
+      // 2. Cross-schema ref (exact match or relative URI)
+      let resolved = ctx.schemaMap.get(schema.$ref)
+      if (!resolved && !schema.$ref.includes('://') && !schema.$ref.startsWith('#')) {
+        for (const [id, s] of ctx.schemaMap) {
+          if (id.endsWith('/' + schema.$ref)) { resolved = s; break }
+        }
+      }
+      if (resolved) {
+        if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return }
+        else {
+          ctx.refStack.add(schema.$ref)
+          genCode(resolved, v, lines, ctx, knownType)
+          ctx.refStack.delete(schema.$ref)
+          if (!hasSiblings) return
+        }
+      } else {
         if (!hasSiblings) return
       }
     } else {
@@ -715,25 +1015,58 @@ function genCode(schema, v, lines, ctx, knownType) {
     }
   }
 
+  // $dynamicRef — resolve via anchors map
+  if (schema.$dynamicRef) {
+    const anchorKey = schema.$dynamicRef.startsWith('#') ? schema.$dynamicRef : '#' + schema.$dynamicRef
+    if (ctx.anchors && ctx.anchors[anchorKey]) {
+      const target = ctx.anchors[anchorKey]
+      if (target === ctx.rootSchema) {
+        // Self-recursive: generate _validate(v) call
+        ctx.usesRecursion = true
+        lines.push(`if(!_validate(${v}))return false`)
+      } else {
+        // Different schema: inline the target validation
+        const refKey = '$dynamicRef:' + anchorKey
+        if (!ctx.refStack.has(refKey)) {
+          ctx.refStack.add(refKey)
+          genCode(target, v, lines, ctx, knownType)
+          ctx.refStack.delete(refKey)
+        }
+      }
+    }
+  }
+
   // Determine the single known type after this schema's type check
   const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null
   let effectiveType = knownType
   if (types) {
     if (!knownType) {
-      // Emit the type check
-      const conds = types.map(t => {
-        switch (t) {
-          case 'object': return `(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
-          case 'array': return `Array.isArray(${v})`
-          case 'string': return `typeof ${v}==='string'`
-          case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
-          case 'integer': return `Number.isInteger(${v})`
-          case 'boolean': return `(${v}===true||${v}===false)`
-          case 'null': return `${v}===null`
-          default: return 'true'
+      // Emit the type check — use direct negation for single types (avoids !() wrapper)
+      if (types.length === 1) {
+        switch (types[0]) {
+          case 'object': lines.push(`if(typeof ${v}!=='object'||${v}===null||Array.isArray(${v}))return false`); break
+          case 'array': lines.push(`if(!Array.isArray(${v}))return false`); break
+          case 'string': lines.push(`if(typeof ${v}!=='string')return false`); break
+          case 'number': lines.push(`if(typeof ${v}!=='number'||!isFinite(${v}))return false`); break
+          case 'integer': lines.push(`if(!Number.isInteger(${v}))return false`); break
+          case 'boolean': lines.push(`if(typeof ${v}!=='boolean')return false`); break
+          case 'null': lines.push(`if(${v}!==null)return false`); break
         }
-      })
-      lines.push(`if(!(${conds.join('||')}))return false`)
+      } else {
+        const conds = types.map(t => {
+          switch (t) {
+            case 'object': return `(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+            case 'array': return `Array.isArray(${v})`
+            case 'string': return `typeof ${v}==='string'`
+            case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
+            case 'integer': return `Number.isInteger(${v})`
+            case 'boolean': return `typeof ${v}==='boolean'`
+            case 'null': return `${v}===null`
+            default: return 'true'
+          }
+        })
+        lines.push(`if(!(${conds.join('||')}))return false`)
+      }
     }
     // If single type, downstream checks can skip guards
     if (types.length === 1) effectiveType = types[0]
@@ -1050,14 +1383,31 @@ function genCode(schema, v, lines, ctx, knownType) {
   if (schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
       if (requiredSet.has(key) && isObj) {
-        // Required + type:object — property exists, use destructured local
-        genCode(prop, hoisted[key] || `${v}[${JSON.stringify(key)}]`, lines, ctx)
+        // Required + type:object — hoist to local to reduce repeated property lookups
+        const access = hoisted[key] || `${v}[${JSON.stringify(key)}]`
+        const combined = tryGenCombined(prop, access, ctx)
+        if (combined) {
+          lines.push(combined)
+        } else if (needsLocal(prop)) {
+          const oi = ctx.varCounter++
+          const local = `_r${oi}`
+          lines.push(`{const ${local}=${access}`)
+          genCode(prop, local, lines, ctx)
+          lines.push(`}`)
+        } else {
+          genCode(prop, access, lines, ctx)
+        }
       } else if (isObj) {
         // Optional — hoist to local, check undefined
         const oi = ctx.varCounter++
         const local = `_o${oi}`
         lines.push(`{const ${local}=${v}[${JSON.stringify(key)}];if(${local}!==undefined){`)
-        genCode(prop, local, lines, ctx)
+        const combined = tryGenCombined(prop, local, ctx)
+        if (combined) {
+          lines.push(combined)
+        } else {
+          genCode(prop, local, lines, ctx)
+        }
         lines.push(`}}`)
       } else {
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}){`)
@@ -1081,15 +1431,15 @@ function genCode(schema, v, lines, ctx, knownType) {
 
   // prefixItems
   if (schema.prefixItems) {
+    const pfxVar = ctx.varCounter++
     for (let i = 0; i < schema.prefixItems.length; i++) {
-      const elem = `_p${ctx.varCounter}_${i}`
+      const elem = `_p${pfxVar}_${i}`
       lines.push(isArr
         ? `if(${v}.length>${i}){const ${elem}=${v}[${i}]`
         : `if(Array.isArray(${v})&&${v}.length>${i}){const ${elem}=${v}[${i}]`)
       genCode(schema.prefixItems[i], elem, lines, ctx)
       lines.push(`}`)
     }
-    ctx.varCounter++
   }
 
   // contains — use helper function to avoid try/catch overhead
@@ -1401,23 +1751,73 @@ function genCode(schema, v, lines, ctx, knownType) {
           const inner = `for(var _k in ${v}){if(!${evVar}[_k])return false}`
           if (!ctx.deferredChecks) ctx.deferredChecks = []
           ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
-        } else if (schema.patternProperties) {
-          // patternProperties: runtime key matching
-          const ei = ctx.varCounter++
-          const evVar = `_ev${ei}`
-          lines.push(`{const ${evVar}={}`)
-          for (const k of baseProps) lines.push(`${evVar}[${JSON.stringify(k)}]=1`)
-          const patterns = Object.keys(schema.patternProperties)
-          const reVars = []
-          for (const pat of patterns) {
-            const ri = ctx.varCounter++
-            ctx.closureVars.push(`_ure${ri}`)
-            ctx.closureVals.push(new RegExp(pat))
-            reVars.push(`_ure${ri}`)
+        } else {
+          // General fallback: collect all patternProperties from root + allOf sub-schemas + if
+          // and use runtime regex matching
+          const allPatterns = []
+          if (schema.patternProperties) {
+            allPatterns.push(...Object.keys(schema.patternProperties))
+          }
+          if (schema.allOf) {
+            for (const sub of schema.allOf) {
+              if (sub && sub.patternProperties) {
+                allPatterns.push(...Object.keys(sub.patternProperties))
+              }
+            }
+          }
+          // lone if (no then/else) still contributes annotations when it passes
+          if (schema.if && !schema.then && !schema.else && schema.if.patternProperties) {
+            allPatterns.push(...Object.keys(schema.if.patternProperties))
+          }
+          if (allPatterns.length > 0) {
+            const ei = ctx.varCounter++
+            const evVar = `_ev${ei}`
+            lines.push(`{const ${evVar}={}`)
+            for (const k of baseProps) lines.push(`${evVar}[${JSON.stringify(k)}]=1`)
+            const reVars = []
+            for (const pat of allPatterns) {
+              const ri = ctx.varCounter++
+              ctx.closureVars.push(`_ure${ri}`)
+              ctx.closureVals.push(new RegExp(pat))
+              reVars.push(`_ure${ri}`)
+            }
+            if (schema.if && !schema.then && !schema.else) {
+              // Lone if: run the if check first; if it passes, its patternProperties contribute
+              const ifLines2 = []
+              genCode(schema.if, '_iv2', ifLines2, ctx)
+              const ufi = ctx.varCounter++
+              const ifFn = ifLines2.length === 0
+                ? `function(_iv2){return true}`
+                : `function(_iv2){${ifLines2.join(';')};return true}`
+              // Mark keys matching if's patterns as evaluated only when if passes
+              const ifPatterns = schema.if.patternProperties ? Object.keys(schema.if.patternProperties) : []
+              const ifReVars = []
+              for (const pat of ifPatterns) {
+                const ri = ctx.varCounter++
+                ctx.closureVars.push(`_ure${ri}`)
+                ctx.closureVals.push(new RegExp(pat))
+                ifReVars.push(`_ure${ri}`)
+              }
+              const rootReVars = []
+              if (schema.patternProperties) {
+                for (const pat of Object.keys(schema.patternProperties)) {
+                  const ri = ctx.varCounter++
+                  ctx.closureVars.push(`_ure${ri}`)
+                  ctx.closureVals.push(new RegExp(pat))
+                  rootReVars.push(`_ure${ri}`)
+                }
+              }
+              const rootPatCheck = rootReVars.map(rv => `if(${rv}.test(_k))continue;`).join('')
+              const ifPatCheck = ifReVars.map(rv => `if(${rv}.test(_k))continue;`).join('')
+              const inner = `const _uif${ufi}=${ifFn};if(_uif${ufi}(${v})){for(var _k in ${v}){if(${evVar}[_k])continue;${rootPatCheck}${ifPatCheck}return false}}else{for(var _k in ${v}){if(${evVar}[_k])continue;${rootPatCheck}return false}}`
+              if (!ctx.deferredChecks) ctx.deferredChecks = []
+              ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+            } else {
+              const inner = `for(var _k in ${v}){if(${evVar}[_k])continue;${reVars.map(rv => `if(${rv}.test(_k)){${evVar}[_k]=1;continue}`).join('')}return false}`
+              if (!ctx.deferredChecks) ctx.deferredChecks = []
+              ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+            }
           }
-          const inner = `for(var _k in ${v}){if(${evVar}[_k])continue;${reVars.map(rv => `if(${rv}.test(_k)){${evVar}[_k]=1;continue}`).join('')}return false}`
-          if (!ctx.deferredChecks) ctx.deferredChecks = []
-          ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
         }
       } else if (typeof schema.unevaluatedProperties === 'object') {
         // Tier 3 with schema: validate unknown keys against sub-schema
@@ -1469,7 +1869,12 @@ function genCode(schema, v, lines, ctx, knownType) {
   if (schema.unevaluatedItems !== undefined) {
     const evalResult = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
 
-    if (evalResult.allItems || schema.unevaluatedItems === true) {
+    // Check if allItems from anyOf/oneOf branches with `items` keyword needs dynamic tracking
+    const branchKw = schema.anyOf ? 'anyOf' : schema.oneOf ? 'oneOf' : null
+    const hasConditionalItems = evalResult.allItems && evalResult.dynamic && branchKw &&
+      schema[branchKw].some(sub => sub && typeof sub === 'object' && ((sub.items && typeof sub.items === 'object') || sub.items === true))
+
+    if (schema.unevaluatedItems === true || (evalResult.allItems && !hasConditionalItems)) {
       // All items evaluated or unevaluatedItems:true — no-op
     } else if (!evalResult.dynamic) {
       // Static: all evaluated items known at compile-time
@@ -1495,16 +1900,29 @@ function genCode(schema, v, lines, ctx, knownType) {
       }
     } else {
       // Dynamic: runtime tracking of max evaluated index
-      const baseIdx = evalResult.items || 0
+      // Compute baseIdx from unconditional sources only (root prefixItems/items, allOf)
+      let baseIdx = 0
+      if (schema.prefixItems) baseIdx = Math.max(baseIdx, schema.prefixItems.length)
+      if (schema.items && typeof schema.items === 'object') baseIdx = Infinity // items: schema → all evaluated
+      if (schema.allOf) {
+        for (const sub of schema.allOf) {
+          const subR = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
+          if (subR.items !== null) baseIdx = Math.max(baseIdx, subR.items)
+          if (subR.allItems) baseIdx = Infinity
+        }
+      }
+      if (baseIdx === Infinity) baseIdx = 0 // allItems already handled above
       const branchKeyword = schema.anyOf ? 'anyOf' : schema.oneOf ? 'oneOf' : null
 
       if (branchKeyword && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
         // anyOf/oneOf: each branch may evaluate different number of items
         const branches = schema[branchKeyword]
         const branchMaxIdx = []
+        const branchAllItems = []
         for (const sub of branches) {
           const subR = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
           branchMaxIdx.push(subR.items || 0)
+          branchAllItems.push(subR.allItems)
         }
         // Runtime: find max evaluated index across all matching branches
         const fns = []
@@ -1518,7 +1936,10 @@ function genCode(schema, v, lines, ctx, knownType) {
         const evVar = `_eidx${ei}`
         lines.push(`{let ${evVar}=${baseIdx}`)
         lines.push(`const _bf${bfi}=[${fns.join(',')}]`)
-        const maxExprs = branchMaxIdx.map((m, i) => `_bi===${i}?${Math.max(m, baseIdx)}`).join(':') + `:${baseIdx}`
+        const maxExprs = branchMaxIdx.map((m, i) => {
+          if (branchAllItems[i]) return `_bi===${i}?${v}.length`
+          return `_bi===${i}?${Math.max(m, baseIdx)}`
+        }).join(':') + `:${baseIdx}`
         if (branchKeyword === 'oneOf') {
           lines.push(`for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){${evVar}=${maxExprs};break}}`)
         } else {
@@ -1543,8 +1964,8 @@ function genCode(schema, v, lines, ctx, knownType) {
             lines.push('}')
           }
         }
-      } else if (schema.if && (schema.then || schema.else) && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
-        // if/then/else: branch-specific max index
+      } else if (schema.if && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
+        // if/then/else (or lone if): branch-specific max index
         const ifEval = collectEvaluated(schema.if, ctx.schemaMap, ctx.rootDefs)
         const thenEval = schema.then ? collectEvaluated(schema.then, ctx.schemaMap, ctx.rootDefs) : { items: null }
         const elseEval = schema.else ? collectEvaluated(schema.else, ctx.schemaMap, ctx.rootDefs) : { items: null }
@@ -1563,6 +1984,54 @@ function genCode(schema, v, lines, ctx, knownType) {
           const guard = isArr ? '' : `if(Array.isArray(${v}))`
           lines.push(`${guard}{const _uif${ufi}=${ifFn3};if(_uif${ufi}(${v})){if(${v}.length>${thenIdx})return false}else{if(${v}.length>${elseIdx})return false}}`)
         }
+      } else if ((schema.contains || (schema.allOf && schema.allOf.some(s => s && s.contains))) && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
+        // contains + unevaluatedItems: per-item tracking of which items are matched by contains
+        // Collect contains from root and allOf sub-schemas
+        const allContains = []
+        if (schema.contains) allContains.push(schema.contains)
+        if (schema.allOf) {
+          for (const sub of schema.allOf) {
+            if (sub && sub.contains) allContains.push(sub.contains)
+          }
+        }
+        const ci = ctx.varCounter++
+        const evArr = `_cev${ci}`
+        const containsFns = []
+        for (const c of allContains) {
+          const cLines = []
+          genCode(c, '_cv', cLines, ctx)
+          containsFns.push(cLines.length === 0
+            ? `function(_cv){return true}`
+            : `function(_cv){${cLines.join(';')};return true}`)
+        }
+        const cfnArr = `_cfn${ci}`
+        lines.push(`{const ${cfnArr}=[${containsFns.join(',')}]`)
+        // Mark items evaluated by prefixItems
+        lines.push(`const ${evArr}=[]`)
+        if (baseIdx > 0) {
+          lines.push(`for(let _i=0;_i<${Math.min(baseIdx, 1000)};_i++)${evArr}[_i]=true`)
+        }
+        // Mark items matched by each contains function
+        lines.push(`if(Array.isArray(${v})){for(let _ci=0;_ci<${v}.length;_ci++){for(let _cj=0;_cj<${cfnArr}.length;_cj++){if(${cfnArr}[_cj](${v}[_ci])){${evArr}[_ci]=true;break}}}}`)
+        if (schema.unevaluatedItems === false) {
+          const inner = `if(Array.isArray(${v})){for(let _ci=0;_ci<${v}.length;_ci++){if(!${evArr}[_ci])return false}}`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(inner + '}')
+        } else {
+          // unevaluatedItems: {schema}
+          const ui = ctx.varCounter++
+          const elemVar = `_ue${ui}`
+          const subLines = []
+          genCode(schema.unevaluatedItems, elemVar, subLines, ctx)
+          if (subLines.length > 0) {
+            const check = subLines.join(';')
+            const inner = `if(Array.isArray(${v})){for(let _ci=0;_ci<${v}.length;_ci++){if(!${evArr}[_ci]){const ${elemVar}=${v}[_ci];${check}}}}`
+            if (!ctx.deferredChecks) ctx.deferredChecks = []
+            ctx.deferredChecks.push(inner + '}')
+          } else {
+            lines.push('}')
+          }
+        }
       } else if (schema.unevaluatedItems === false) {
         // Fallback: use static base index (may not be fully correct for all dynamic cases)
         const maxIdx = evalResult.items || 0
@@ -1582,8 +2051,8 @@ const FORMAT_CODEGEN = {
       : `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`
-    : `if(typeof ${v}==='string'&&(${v}.length!==10||!/^\\d{4}-\\d{2}-\\d{2}$/.test(${v})))return false`,
+    ? `{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}`,
   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`,
@@ -1741,6 +2210,8 @@ function compileToJSCodegenWithErrors(schema, schemaMap) {
   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
@@ -1770,15 +2241,46 @@ function compileToJSCodegenWithErrors(schema, schemaMap) {
     if (keys.some(k => !supported.includes(k))) return null
   }
 
-  const ctx = { varCounter: 0, helperCode: [], rootDefs: schema.$defs || schema.definitions || null, refStack: new Set(), schemaMap: schemaMap || null }
+  // Build anchors map for $ref/#anchor and $dynamicRef resolution
+  const eRootDefs = schema.$defs || schema.definitions || null
+  const eAnchors = {}
+  if (schema.$dynamicAnchor) eAnchors['#' + schema.$dynamicAnchor] = schema
+  if (schema.$anchor) eAnchors['#' + schema.$anchor] = schema
+  if (eRootDefs) {
+    for (const def of Object.values(eRootDefs)) {
+      if (def && typeof def === 'object') {
+        if (def.$dynamicAnchor) eAnchors['#' + def.$dynamicAnchor] = def
+        if (def.$anchor) eAnchors['#' + def.$anchor] = def
+      }
+    }
+  }
+  if (schemaMap) {
+    for (const ext of schemaMap.values()) {
+      if (ext && typeof ext === 'object') {
+        if (ext.$dynamicAnchor && !eAnchors['#' + ext.$dynamicAnchor]) eAnchors['#' + ext.$dynamicAnchor] = ext
+        if (ext.$anchor && !eAnchors['#' + ext.$anchor]) eAnchors['#' + ext.$anchor] = ext
+      }
+    }
+  }
+
+  const ctx = { varCounter: 0, helperCode: [], rootDefs: eRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: eAnchors, rootSchema: schema }
   const lines = []
   genCodeE(schema, 'd', '', lines, ctx, '#')
   if (lines.length === 0) return (d) => ({ valid: true, errors: [] })
 
-  const body = `const _e=[];\n  ` +
-    (ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : '') +
-    lines.join('\n  ') +
-    `\n  return{valid:_e.length===0,errors:_e}`
+  const checkStr = lines.join('\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  ` +
+      `return{valid:_e.length===0,errors:_e}`
+  } else {
+    body = `const _e=[];\n  ` +
+      (ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : '') +
+      checkStr +
+      `\n  return{valid:_e.length===0,errors:_e}`
+  }
   try {
     const fn = new Function('d', '_all', body)
     fn._errSource = body
@@ -1797,6 +2299,8 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 
   // $ref — resolve local and cross-schema refs
   if (schema.$ref) {
+    // Self-reference "#" — no-op (permissive) to avoid infinite recursion
+    if (schema.$ref === '#') return
     const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
     if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
       if (ctx.refStack.has(schema.$ref)) return
@@ -1805,6 +2309,18 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       ctx.refStack.delete(schema.$ref)
       return
     }
+    // Anchor ref: "#foo" — resolve via rootDefs or anchors map
+    if (!m && schema.$ref.startsWith('#') && !schema.$ref.startsWith('#/')) {
+      const entry = ctx.rootDefs && ctx.rootDefs[schema.$ref]
+      const anchorTarget = entry && entry.raw ? entry.raw : (ctx.anchors && ctx.anchors[schema.$ref])
+      if (anchorTarget) {
+        if (ctx.refStack.has(schema.$ref)) return
+        ctx.refStack.add(schema.$ref)
+        genCodeE(anchorTarget, v, pathExpr, lines, ctx, schemaPrefix)
+        ctx.refStack.delete(schema.$ref)
+        return
+      }
+    }
     if (ctx.schemaMap && ctx.schemaMap.has(schema.$ref)) {
       if (ctx.refStack.has(schema.$ref)) return
       ctx.refStack.add(schema.$ref)
@@ -1814,6 +2330,26 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     }
   }
 
+  // $dynamicRef — resolve via anchors map
+  if (schema.$dynamicRef) {
+    const anchorKey = schema.$dynamicRef.startsWith('#') ? schema.$dynamicRef : '#' + schema.$dynamicRef
+    if (ctx.anchors && ctx.anchors[anchorKey]) {
+      const target = ctx.anchors[anchorKey]
+      if (target === ctx.rootSchema) {
+        // Self-recursive: generate _validateE call
+        ctx.usesRecursion = true
+        lines.push(`_validateE(${v},_all,_e)`)
+      } else {
+        const refKey = '$dynamicRef:' + anchorKey
+        if (!ctx.refStack.has(refKey)) {
+          ctx.refStack.add(refKey)
+          genCodeE(target, v, pathExpr, lines, ctx, schemaPrefix)
+          ctx.refStack.delete(refKey)
+        }
+      }
+    }
+  }
+
   const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null
   if (types) {
     const conds = types.map(t => {
@@ -1823,7 +2359,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         case 'string': return `typeof ${v}==='string'`
         case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
         case 'integer': return `Number.isInteger(${v})`
-        case 'boolean': return `(${v}===true||${v}===false)`
+        case 'boolean': return `typeof ${v}==='boolean'`
         case 'null': return `${v}===null`
         default: return 'true'
       }
@@ -1864,8 +2400,8 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       const ci = ctx.varCounter++
       const canonFn = `_cnE${ci}`
       ctx.helperCode.push(`const ${canonFn}=function(x){if(x===null||typeof x!=='object')return JSON.stringify(x);if(Array.isArray(x))return'['+x.map(${canonFn}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+${canonFn}(x[k])}).join(',')+'}'};`)
-      const expected = canonFn + '(' + JSON.stringify(cv) + ')'
-      lines.push(`if(${canonFn}(${v})!==${expected}){${fail('const', 'const', `{allowedValue:${JSON.stringify(schema.const)}}`, "'must be equal to constant'")}}`)
+      const expected = canonFn + '(JSON.parse(' + JSON.stringify(JSON.stringify(cv)) + '))'
+      lines.push(`if(${canonFn}(${v})!==${expected}){${fail('const', 'const', `{allowedValue:JSON.parse(${JSON.stringify(JSON.stringify(schema.const))})}`, "'must be equal to constant'")}}`)
     }
   }
 
@@ -2157,6 +2693,8 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap) {
   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 — combined codegen doesn't support recursion
+    if (s.includes('"$ref":"#"')) return null
   }
   if (typeof schema === 'boolean') {
     return schema
@@ -2186,8 +2724,30 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap) {
     if (keys.some(k => !supported.includes(k))) return null
   }
 
+  // Build anchors map for $ref/#anchor and $dynamicRef resolution
+  const cRootDefs = schema.$defs || schema.definitions || null
+  const cAnchors = {}
+  if (schema.$dynamicAnchor) cAnchors['#' + schema.$dynamicAnchor] = schema
+  if (schema.$anchor) cAnchors['#' + schema.$anchor] = schema
+  if (cRootDefs) {
+    for (const def of Object.values(cRootDefs)) {
+      if (def && typeof def === 'object') {
+        if (def.$dynamicAnchor) cAnchors['#' + def.$dynamicAnchor] = def
+        if (def.$anchor) cAnchors['#' + def.$anchor] = def
+      }
+    }
+  }
+  if (schemaMap) {
+    for (const ext of schemaMap.values()) {
+      if (ext && typeof ext === 'object') {
+        if (ext.$dynamicAnchor && !cAnchors['#' + ext.$dynamicAnchor]) cAnchors['#' + ext.$dynamicAnchor] = ext
+        if (ext.$anchor && !cAnchors['#' + ext.$anchor]) cAnchors['#' + ext.$anchor] = ext
+      }
+    }
+  }
+
   const ctx = { varCounter: 0, helperCode: [], closureVars: [], closureVals: [],
-                rootDefs: schema.$defs || schema.definitions || null, refStack: new Set(), schemaMap: schemaMap || null }
+                rootDefs: cRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: cAnchors, rootSchema: schema }
   const lines = []
   genCodeC(schema, 'd', '', lines, ctx, '#')
   if (lines.length === 0) return () => VALID_RESULT
@@ -2218,8 +2778,10 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (!schemaPrefix) schemaPrefix = '#'
   if (typeof schema !== 'object' || schema === null) return
 
-  // $ref — resolve local and cross-schema refs
+  // $ref — resolve local, anchor, and cross-schema refs
   if (schema.$ref) {
+    // Self-reference "#" — no-op (permissive) to avoid infinite recursion
+    if (schema.$ref === '#') return
     const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
     if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
       if (ctx.refStack.has(schema.$ref)) return
@@ -2228,6 +2790,18 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       ctx.refStack.delete(schema.$ref)
       return
     }
+    // Anchor ref: "#foo" — resolve via rootDefs or anchors map
+    if (!m && schema.$ref.startsWith('#') && !schema.$ref.startsWith('#/')) {
+      const entry = ctx.rootDefs && ctx.rootDefs[schema.$ref]
+      const anchorTarget = entry && entry.raw ? entry.raw : (ctx.anchors && ctx.anchors[schema.$ref])
+      if (anchorTarget) {
+        if (ctx.refStack.has(schema.$ref)) return
+        ctx.refStack.add(schema.$ref)
+        genCodeC(anchorTarget, v, pathExpr, lines, ctx, schemaPrefix)
+        ctx.refStack.delete(schema.$ref)
+        return
+      }
+    }
     if (ctx.schemaMap && ctx.schemaMap.has(schema.$ref)) {
       if (ctx.refStack.has(schema.$ref)) return
       ctx.refStack.add(schema.$ref)
@@ -2237,6 +2811,25 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     }
   }
 
+  // $dynamicRef — resolve via anchors map
+  if (schema.$dynamicRef) {
+    const anchorKey = schema.$dynamicRef.startsWith('#') ? schema.$dynamicRef : '#' + schema.$dynamicRef
+    if (ctx.anchors && ctx.anchors[anchorKey]) {
+      const target = ctx.anchors[anchorKey]
+      if (target === ctx.rootSchema) {
+        // Self-recursive: bail to non-combined path (combined doesn't support named recursion)
+        // Just skip — the hybrid path will handle this via jsFn + errFn
+      } else {
+        const refKey = '$dynamicRef:' + anchorKey
+        if (!ctx.refStack.has(refKey)) {
+          ctx.refStack.add(refKey)
+          genCodeC(target, v, pathExpr, lines, ctx, schemaPrefix)
+          ctx.refStack.delete(refKey)
+        }
+      }
+    }
+  }
+
   const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null
   let isObj = false, isArr = false, isStr = false, isNum = false
 
@@ -2272,7 +2865,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         case 'string': return `typeof ${v}==='string'`
         case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
         case 'integer': return `Number.isInteger(${v})`
-        case 'boolean': return `(${v}===true||${v}===false)`
+        case 'boolean': return `typeof ${v}==='boolean'`
         case 'null': return `${v}===null`
         default: return 'true'
       }
@@ -2312,7 +2905,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       const ci = ctx.varCounter++
       const canonFn = `_cn${ci}`
       ctx.helperCode.push(`const ${canonFn}=function(x){if(x===null||typeof x!=='object')return JSON.stringify(x);if(Array.isArray(x))return'['+x.map(${canonFn}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+${canonFn}(x[k])}).join(',')+'}'};`)
-      lines.push(`if(${canonFn}(${v})!==${canonFn}(${JSON.stringify(cv)})){${fail('const', 'const', `{allowedValue:${JSON.stringify(schema.const)}}`, "'must be equal to constant'")}}`)
+      lines.push(`if(${canonFn}(${v})!==${canonFn}(JSON.parse(${JSON.stringify(JSON.stringify(cv))}))){${fail('const', 'const', `{allowedValue:JSON.parse(${JSON.stringify(JSON.stringify(schema.const))})}`, "'must be equal to constant'")}}`)
     }
   }
 
@@ -2729,11 +3322,20 @@ function _collectEval(schema, result, defs, schemaMap, refStack, isRoot) {
       refStack.add(schema.$ref)
       _collectEval(defs[m[1]], result, defs, schemaMap, refStack)
       refStack.delete(schema.$ref)
-    } else if (schemaMap && typeof schemaMap.get === 'function' && schemaMap.has(schema.$ref)) {
-      if (refStack.has(schema.$ref)) { result.dynamic = true; return }
-      refStack.add(schema.$ref)
-      _collectEval(schemaMap.get(schema.$ref), result, defs, schemaMap, refStack)
-      refStack.delete(schema.$ref)
+    } else if (schemaMap && typeof schemaMap.get === 'function') {
+      let resolved = schemaMap.has(schema.$ref) ? schemaMap.get(schema.$ref) : null
+      // Relative URI resolution
+      if (!resolved && !schema.$ref.includes('://') && !schema.$ref.startsWith('#')) {
+        for (const [id, s] of schemaMap) {
+          if (id.endsWith('/' + schema.$ref)) { resolved = s; break }
+        }
+      }
+      if (resolved) {
+        if (refStack.has(schema.$ref)) { result.dynamic = true; return }
+        refStack.add(schema.$ref)
+        _collectEval(resolved, result, defs, schemaMap, refStack)
+        refStack.delete(schema.$ref)
+      }
     }
     // In 2020-12, $ref can coexist with siblings — don't return early if there are other keywords
     const hasOtherKeywords = Object.keys(schema).some(k => k !== '$ref' && k !== '$defs' && k !== 'definitions' && k !== '$schema' && k !== '$id')
@@ -2771,15 +3373,10 @@ function _collectEval(schema, result, defs, schemaMap, refStack, isRoot) {
     result.allItems = true
   }
 
-  // contains interaction with unevaluatedItems is complex
-  // At root level: contains + unevaluatedItems needs dynamic tracking
-  // In nested schemas: contains marks all items as evaluated
+  // contains: marks matching items as evaluated (not ALL items)
+  // Always set dynamic since which items match depends on the data
   if (schema.contains) {
-    if (isRoot && (schema.unevaluatedItems !== undefined)) {
-      result.dynamic = true
-    } else {
-      result.allItems = true
-    }
+    result.dynamic = true
   }
 
   // unevaluatedProperties: true/schema → all props evaluated (for nested schemas only)
@@ -2814,6 +3411,18 @@ function _collectEval(schema, result, defs, schemaMap, refStack, isRoot) {
     _collectEval(schema.if, result, defs, schemaMap, refStack)
     if (schema.then) _collectEval(schema.then, result, defs, schemaMap, refStack)
     if (schema.else) _collectEval(schema.else, result, defs, schemaMap, refStack)
+  } else if (schema.if) {
+    // Standalone if (no then/else) still produces annotations per spec
+    // Only collect properties and patterns, not deep items (contains etc.)
+    result.dynamic = true
+    if (schema.if.properties) {
+      for (const k of Object.keys(schema.if.properties)) {
+        if (!result.props.includes(k)) result.props.push(k)
+      }
+    }
+    if (schema.if.patternProperties) {
+      // patternProperties contribute to dynamic evaluation
+    }
   }
 
   // dependentSchemas → dynamic