ata-validator 0.7.3 → 0.8.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)`
+    const hybridCheck = replaceTopLevel(checkStr + '\n  return R')
+    hybridBody = `function _validate(d){\n  ${hybridCheck}\n  }\n  return _validate(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)
@@ -691,8 +884,12 @@ 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 "#" — no-op (permissive) to avoid infinite recursion
+    if (schema.$ref === '#') {
+      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 +898,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,6 +935,27 @@ 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
@@ -1582,8 +1823,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`,
@@ -1770,15 +2011,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 +2069,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 +2079,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 +2100,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 => {
@@ -1864,8 +2170,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'")}}`)
     }
   }
 
@@ -2186,8 +2492,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 +2546,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 +2558,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 +2579,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
 
@@ -2312,7 +2673,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 +3090,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')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.7.3",
+  "version": "0.8.0",
   "description": "Ultra-fast JSON Schema validator. 4.7x faster validation, 1,800x faster compilation. Works without native addon. Cross-schema $ref, Draft 2020-12 + Draft 7, V8-optimized JS codegen, simdjson, RE2, multi-core. Standard Schema V1 compatible.",
   "main": "index.js",
   "module": "index.mjs",
@@ -38,7 +38,8 @@
     "test:browser": "node tests/test_browser.js",
     "bench": "node benchmark/bench_large.js",
     "fuzz": "node tests/fuzz_differential.js",
-    "fuzz:long": "FUZZ_ITERATIONS=100000 node tests/fuzz_differential.js"
+    "fuzz:long": "FUZZ_ITERATIONS=100000 node tests/fuzz_differential.js",
+    "test:json-suite": "node tests/run_json_test_suite.js"
   },
   "keywords": [
     "json",