ata-validator 0.4.15 → 0.5.0

package/lib/js-compiler.js

@@ -4,14 +4,14 @@
 // Closure-based validator — no new Function() or eval().
 // Returns null if the schema is too complex for JS compilation.
 
-function compileToJS(schema, defs) {
+function compileToJS(schema, defs, schemaMap) {
   if (typeof schema === 'boolean') {
     return schema ? () => true : () => false
   }
   if (typeof schema !== 'object' || schema === null) return null
 
   // Bail if schema has edge cases that JS fast path gets wrong
-  if (!defs && !codegenSafe(schema)) return null
+  if (!defs && !codegenSafe(schema, schemaMap)) return null
 
   // Collect $defs early so sub-schemas can resolve $ref
   const rootDefs = defs || collectDefs(schema)
@@ -27,7 +27,7 @@ function compileToJS(schema, defs) {
 
   // $ref (local only)
   if (schema.$ref) {
-    const refFn = resolveRef(schema.$ref, rootDefs)
+    const refFn = resolveRef(schema.$ref, rootDefs, schemaMap)
     if (!refFn) return null
     checks.push(refFn)
   }
@@ -372,18 +372,23 @@ function collectDefs(schema) {
   return defs
 }
 
-function resolveRef(ref, defs) {
-  if (!defs) return null
-  // #/$defs/Name or #/definitions/Name
-  const m = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
-  if (!m) return null
-  const name = m[1]
-  const entry = defs[name]
-  if (!entry) return null
-  return (d) => {
-    const fn = entry.fn
-    return fn ? fn(d) : true
+function resolveRef(ref, defs, schemaMap) {
+  // 1. Local ref
+  if (defs) {
+    const m = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
+    if (m) {
+      const name = m[1]
+      const entry = defs[name]
+      if (entry) return (d) => { const fn = entry.fn; return fn ? fn(d) : true }
+    }
+  }
+  // 2. Cross-schema ref
+  if (schemaMap && schemaMap.has(ref)) {
+    const resolved = schemaMap.get(ref)
+    const fn = compileToJS(resolved, null, schemaMap)
+    return fn || (() => true)
   }
+  return null
 }
 
 function buildTypeCheck(types) {
@@ -423,7 +428,7 @@ const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'toString', 'valueOf',
 
 // 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) {
+function codegenSafe(schema, schemaMap) {
   if (typeof schema === 'boolean') return true
   if (typeof schema !== 'object' || schema === null) return true
 
@@ -433,7 +438,7 @@ function codegenSafe(schema) {
   if (schema.properties) {
     for (const v of Object.values(schema.properties)) {
       if (typeof v === 'boolean') return false
-      if (!codegenSafe(v)) return false
+      if (!codegenSafe(v, schemaMap)) return false
     }
   }
 
@@ -453,14 +458,15 @@ function codegenSafe(schema) {
   // Unicode property escapes in pattern need 'u' flag — codegen uses RegExp without it
   if (schema.pattern && /\\[pP]\{/.test(schema.pattern)) return false
 
-  // $ref — allow only simple local refs (#/$defs/Name), no $id, no sibling keywords
+  // $ref — allow local refs (#/$defs/Name) and non-local refs if in schemaMap
   if (schema.$ref) {
-    if (!/^#\/(?:\$defs|definitions)\/[^/]+$/.test(schema.$ref)) return false
+    const isLocal = /^#\/(?:\$defs|definitions)\/[^/]+$/.test(schema.$ref)
+    const isResolvable = !isLocal && schemaMap && schemaMap.has(schema.$ref)
+    if (!isLocal && !isResolvable) return false
     // Bail if $ref has sibling keywords (complex interaction)
-    const siblings = Object.keys(schema).filter(k => k !== '$ref' && k !== '$defs' && k !== 'definitions' && k !== '$schema')
+    const siblings = Object.keys(schema).filter(k => k !== '$ref' && k !== '$defs' && k !== 'definitions' && k !== '$schema' && k !== '$id')
     if (siblings.length > 0) return false
   }
-  if (schema.$id) return false
 
   // additionalProperties as schema — bail entirely, too many edge cases with allOf interaction
   if (typeof schema.additionalProperties === 'object') return false
@@ -476,8 +482,9 @@ function codegenSafe(schema) {
       if (/[~/"']/.test(name)) return false // special chars in def name
       if (typeof def === 'boolean') return false
       if (typeof def === 'object' && def !== null) {
+        if (def.$id) return false // $id in $defs creates new resolution scope — bail
         if (def.$ref) return false // nested ref chain — bail
-        if (!codegenSafe(def)) return false
+        if (!codegenSafe(def, schemaMap)) return false
       }
     }
   }
@@ -495,7 +502,7 @@ function codegenSafe(schema) {
   for (const s of subs) {
     if (s === undefined || s === null) continue
     if (typeof s === 'boolean') return false // boolean sub-schema
-    if (!codegenSafe(s)) return false
+    if (!codegenSafe(s, schemaMap)) return false
   }
 
   return true
@@ -503,22 +510,42 @@ function codegenSafe(schema) {
 
 // --- Codegen mode: generates a single Function (NOT CSP-safe) ---
 // This matches ajv's approach: one monolithic function, V8 JIT fully inlines it
-function compileToJSCodegen(schema) {
+function compileToJSCodegen(schema, schemaMap) {
   if (typeof schema === 'boolean') return schema ? () => true : () => false
   if (typeof schema !== 'object' || schema === null) return null
 
   // Bail if schema contains features that codegen can't handle correctly
-  if (!codegenSafe(schema)) return null
+  if (!codegenSafe(schema, schemaMap)) return null
 
   // Collect defs for $ref resolution
   const rootDefs = schema.$defs || schema.definitions || null
 
   // Bail only on truly unsupported features
-  if (schema.patternProperties ||
-      schema.dependentSchemas ||
-      schema.propertyNames) return null
+  // 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
+    }
+  }
+  // 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')
+    if (keys.some(k => !supported.includes(k))) return null
+  }
 
-  const ctx = { varCounter: 0, helpers: [], helperCode: [], closureVars: [], closureVals: [], rootDefs, refStack: new Set() }
+  const ctx = { varCounter: 0, helpers: [], helperCode: [], closureVars: [], closureVals: [], rootDefs, refStack: new Set(), schemaMap: schemaMap || null }
   const lines = []
   genCode(schema, 'd', lines, ctx)
   if (lines.length === 0) return () => true
@@ -614,16 +641,25 @@ function genCode(schema, v, lines, ctx, knownType) {
   if (typeof schema !== 'object' || schema === null) return
 
   // $ref — guard against circular references
-  if (schema.$ref && ctx.rootDefs) {
+  if (schema.$ref) {
+    // 1. Local ref
     const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
-    if (m && ctx.rootDefs[m[1]]) {
-      if (ctx.refStack.has(schema.$ref)) return // circular — bail
+    if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
+      if (ctx.refStack.has(schema.$ref)) return
       ctx.refStack.add(schema.$ref)
       genCode(ctx.rootDefs[m[1]], v, lines, ctx, knownType)
       ctx.refStack.delete(schema.$ref)
-    } else {
       return
     }
+    // 2. Cross-schema ref
+    if (ctx.schemaMap && ctx.schemaMap.has(schema.$ref)) {
+      if (ctx.refStack.has(schema.$ref)) return
+      ctx.refStack.add(schema.$ref)
+      genCode(ctx.schemaMap.get(schema.$ref), v, lines, ctx, knownType)
+      ctx.refStack.delete(schema.$ref)
+      return
+    }
+    return
   }
 
   // Determine the single known type after this schema's type check
@@ -757,19 +793,15 @@ function genCode(schema, v, lines, ctx, knownType) {
 
   // additionalProperties -- deferred to end of function for better V8 optimization
   // (type checks run first in hot path, expensive prop count check last)
-  if (schema.additionalProperties === false && schema.properties) {
+  // Skip if patternProperties is present — it will handle additionalProperties in a unified loop
+  if (schema.additionalProperties === false && schema.properties && !schema.patternProperties) {
     const propCount = Object.keys(schema.properties).length
-    if (!schema.patternProperties) {
-      const inner = `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount})return false`
-      if (!ctx.deferredChecks) ctx.deferredChecks = []
-      ctx.deferredChecks.push(isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
-    } else {
-      const allowed = Object.keys(schema.properties).map(k => `'${esc(k)}'`).join(',')
-      const ci = ctx.varCounter++
-      const inner = `const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++)if(!_a${ci}.has(_k${ci}[_i]))return false`
-      if (!ctx.deferredChecks) ctx.deferredChecks = []
-      ctx.deferredChecks.push(isObj ? `{${inner}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
-    }
+    const allRequired = schema.required && schema.required.length === propCount
+    const inner = allRequired
+      ? `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount})return false`
+      : `for(var _k in ${v})if(${Object.keys(schema.properties).map(k => `_k!==${JSON.stringify(k)}`).join('&&')})return false`
+    if (!ctx.deferredChecks) ctx.deferredChecks = []
+    ctx.deferredChecks.push(isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
   }
 
   // dependentRequired
@@ -780,6 +812,162 @@ function genCode(schema, v, lines, ctx, knownType) {
     }
   }
 
+  // patternProperties + propertyNames + additionalProperties — unified key iteration
+  // Merges up to 3 separate for..in loops into one pass.
+  if (schema.patternProperties) {
+    const ppEntries = Object.entries(schema.patternProperties)
+    const pn = schema.propertyNames && typeof schema.propertyNames === 'object' ? schema.propertyNames : null
+    const pi = ctx.varCounter++
+    const kVar = `_ppk${pi}`
+
+    // Build pattern matchers: prefer charCodeAt for simple prefixes, fall back to regex
+    const matchers = []
+    for (const [pat] of ppEntries) {
+      const fast = fastPrefixCheck(pat, kVar)
+      if (fast) {
+        matchers.push({ check: fast })
+      } else {
+        const ri = ctx.varCounter++
+        ctx.closureVars.push(`_re${ri}`)
+        ctx.closureVals.push(new RegExp(pat))
+        matchers.push({ check: `_re${ri}.test(${kVar})` })
+      }
+    }
+
+    // Build sub-schema validators as closure vars
+    for (let i = 0; i < ppEntries.length; i++) {
+      const [, sub] = ppEntries[i]
+      const subLines = []
+      genCode(sub, `_ppv`, subLines, ctx)
+      const fnBody = subLines.length === 0 ? `return true` : `${subLines.join(';')};return true`
+      const fnVar = `_ppf${pi}_${i}`
+      ctx.closureVars.push(fnVar)
+      ctx.closureVals.push(new Function('_ppv', fnBody))
+    }
+
+    const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+
+    if (schema.additionalProperties === false && schema.properties) {
+      // Unified loop: properties + patterns + propertyNames + additionalProperties
+      ctx._ppHandledAdditional = true
+      ctx._ppHandledPropertyNames = !!pn
+      const propKeys = Object.keys(schema.properties)
+      // Inline key comparison instead of Set.has for small property counts (faster, no allocation)
+      const keyCheck = propKeys.length <= 8
+        ? propKeys.map(k => `${kVar}===${JSON.stringify(k)}`).join('||')
+        : null
+      if (!keyCheck) {
+        const allowedSet = `_as${pi}`
+        ctx.closureVars.push(allowedSet)
+        ctx.closureVals.push(new Set(propKeys))
+      }
+
+      lines.push(`${guard}{for(const ${kVar} in ${v}){`)
+      // propertyNames checks (merged into same loop)
+      if (pn) {
+        if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength})return false`)
+        if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength})return false`)
+        if (pn.pattern) {
+          const fast = fastPrefixCheck(pn.pattern, kVar)
+          if (fast) {
+            lines.push(`if(!(${fast}))return false`)
+          } else {
+            const ri = ctx.varCounter++
+            ctx.closureVars.push(`_re${ri}`)
+            ctx.closureVals.push(new RegExp(pn.pattern))
+            lines.push(`if(!_re${ri}.test(${kVar}))return false`)
+          }
+        }
+        if (pn.const !== undefined) lines.push(`if(${kVar}!==${JSON.stringify(pn.const)})return false`)
+        if (pn.enum) {
+          const ei = ctx.varCounter++
+          ctx.closureVars.push(`_es${ei}`)
+          ctx.closureVals.push(new Set(pn.enum))
+          lines.push(`if(!_es${ei}.has(${kVar}))return false`)
+        }
+      }
+      // Check: is key in declared properties?
+      const matchExpr = keyCheck || `_as${pi}.has(${kVar})`
+      lines.push(`let _m${pi}=${matchExpr}`)
+      // Check pattern matches
+      for (let i = 0; i < ppEntries.length; i++) {
+        lines.push(`if(${matchers[i].check}){_m${pi}=true;if(!_ppf${pi}_${i}(${v}[${kVar}]))return false}`)
+      }
+      lines.push(`if(!_m${pi})return false`)
+      lines.push(`}}`)
+    } else {
+      // No additionalProperties: validate matching keys + propertyNames
+      ctx._ppHandledPropertyNames = !!pn
+      lines.push(`${guard}{for(const ${kVar} in ${v}){`)
+      // propertyNames checks (merged)
+      if (pn) {
+        if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength})return false`)
+        if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength})return false`)
+        if (pn.pattern) {
+          const fast = fastPrefixCheck(pn.pattern, kVar)
+          if (fast) {
+            lines.push(`if(!(${fast}))return false`)
+          } else {
+            const ri = ctx.varCounter++
+            ctx.closureVars.push(`_re${ri}`)
+            ctx.closureVals.push(new RegExp(pn.pattern))
+            lines.push(`if(!_re${ri}.test(${kVar}))return false`)
+          }
+        }
+        if (pn.const !== undefined) lines.push(`if(${kVar}!==${JSON.stringify(pn.const)})return false`)
+        if (pn.enum) {
+          const ei = ctx.varCounter++
+          ctx.closureVars.push(`_es${ei}`)
+          ctx.closureVals.push(new Set(pn.enum))
+          lines.push(`if(!_es${ei}.has(${kVar}))return false`)
+        }
+      }
+      for (let i = 0; i < ppEntries.length; i++) {
+        lines.push(`if(${matchers[i].check}&&!_ppf${pi}_${i}(${v}[${kVar}]))return false`)
+      }
+      lines.push(`}}`)
+    }
+  }
+
+  // dependentSchemas
+  if (schema.dependentSchemas) {
+    for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
+      const guard = isObj ? '' : `typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&`
+      lines.push(`if(${guard}${JSON.stringify(key)} in ${v}){`)
+      genCode(depSchema, v, lines, ctx, effectiveType)
+      lines.push(`}`)
+    }
+  }
+
+  // propertyNames — only emit if not already merged into patternProperties loop
+  if (schema.propertyNames && typeof schema.propertyNames === 'object' && !ctx._ppHandledPropertyNames) {
+    const pn = schema.propertyNames
+    const ki = ctx.varCounter++
+    const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+    lines.push(`${guard}{for(const _k${ki} in ${v}){`)
+    if (pn.minLength !== undefined) lines.push(`if(_k${ki}.length<${pn.minLength})return false`)
+    if (pn.maxLength !== undefined) lines.push(`if(_k${ki}.length>${pn.maxLength})return false`)
+    if (pn.pattern) {
+      const fast = fastPrefixCheck(pn.pattern, `_k${ki}`)
+      if (fast) {
+        lines.push(`if(!(${fast}))return false`)
+      } else {
+        const ri = ctx.varCounter++
+        ctx.closureVars.push(`_re${ri}`)
+        ctx.closureVals.push(new RegExp(pn.pattern))
+        lines.push(`if(!_re${ri}.test(_k${ki}))return false`)
+      }
+    }
+    if (pn.const !== undefined) lines.push(`if(_k${ki}!==${JSON.stringify(pn.const)})return false`)
+    if (pn.enum) {
+      const ei = ctx.varCounter++
+      ctx.closureVars.push(`_es${ei}`)
+      ctx.closureVals.push(new Set(pn.enum))
+      lines.push(`if(!_es${ei}.has(_k${ki}))return false`)
+    }
+    lines.push(`}}`)
+  }
+
   // properties — use hoisted vars for required props, hoist optional to locals too
   if (schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
@@ -937,28 +1125,86 @@ const FORMAT_CODEGEN = {
   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}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})$/.test(${v})||isNaN(Date.parse(${v})))return false`
+    : `if(typeof ${v}==='string'&&(!/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})$/.test(${v})||isNaN(Date.parse(${v}))))return false`,
+  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`,
+  duration: (v, isStr) => isStr
+    ? `if(!/^P(?:\\d+Y)?(?:\\d+M)?(?:\\d+W)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+(?:\\.\\d+)?S)?)?$/.test(${v})||${v}==='P')return false`
+    : `if(typeof ${v}==='string'&&(!/^P(?:\\d+Y)?(?:\\d+M)?(?:\\d+W)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+(?:\\.\\d+)?S)?)?$/.test(${v})||${v}==='P'))return false`,
+  uri: (v, isStr) => isStr
+    ? `if(!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(${v}))return false`
+    : `if(typeof ${v}==='string'&&!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(${v}))return false`,
+  'uri-reference': (v, isStr) => isStr
+    ? `if(${v}===''||/\\s/.test(${v}))return false`
+    : `if(typeof ${v}==='string'&&(${v}===''||/\\s/.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`,
 }
 
 // Safe key escaping: use JSON.stringify to handle all special chars (newlines, null bytes, etc.)
 function esc(s) { return JSON.stringify(s).slice(1, -1) }
 
+// Detect simple prefix patterns like "^x-", "^_", "^prefix" and generate fast charCodeAt checks
+// Returns a JS expression string or null if pattern is too complex
+function fastPrefixCheck(pattern, keyVar) {
+  // Match patterns like ^literal (no regex metacharacters after ^)
+  const m = pattern.match(/^\^([a-zA-Z0-9_\-./]+)$/)
+  if (!m) return null
+  const prefix = m[1]
+  if (prefix.length === 0 || prefix.length > 8) return null // too long = diminishing returns
+  if (prefix.length === 1) {
+    return `${keyVar}.charCodeAt(0)===${prefix.charCodeAt(0)}`
+  }
+  if (prefix.length === 2) {
+    return `${keyVar}.charCodeAt(0)===${prefix.charCodeAt(0)}&&${keyVar}.charCodeAt(1)===${prefix.charCodeAt(1)}`
+  }
+  // For longer prefixes, startsWith is cleaner and still faster than regex
+  return `${keyVar}.startsWith(${JSON.stringify(prefix)})`
+}
+
 // --- Error-collecting codegen: same checks, but pushes errors instead of returning false ---
 // Returns a function: (data, allErrors) => { valid, errors }
 // Valid path is still fast — only error path does extra work.
-function compileToJSCodegenWithErrors(schema) {
+function compileToJSCodegenWithErrors(schema, schemaMap) {
   if (typeof schema === 'boolean') {
     return schema
       ? () => ({ valid: true, errors: [] })
       : () => ({ valid: false, errors: [{ code: 'type_mismatch', path: '', message: 'schema is false' }] })
   }
   if (typeof schema !== 'object' || schema === null) return null
-  if (!codegenSafe(schema)) return null
-  if (schema.patternProperties || schema.dependentSchemas || schema.propertyNames) return null
+  if (!codegenSafe(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')
+    if (keys.some(k => !supported.includes(k))) return null
+  }
 
-  const ctx = { varCounter: 0, helperCode: [], rootDefs: schema.$defs || schema.definitions || null, refStack: new Set() }
+  const ctx = { varCounter: 0, helperCode: [], rootDefs: schema.$defs || schema.definitions || null, refStack: new Set(), schemaMap: schemaMap || null }
   const lines = []
   genCodeE(schema, 'd', '', lines, ctx)
   if (lines.length === 0) return (d) => ({ valid: true, errors: [] })
@@ -982,11 +1228,22 @@ function compileToJSCodegenWithErrors(schema) {
 function genCodeE(schema, v, pathExpr, lines, ctx) {
   if (typeof schema !== 'object' || schema === null) return
 
-  // $ref — resolve local refs
-  if (schema.$ref && ctx.rootDefs) {
+  // $ref — resolve local and cross-schema refs
+  if (schema.$ref) {
     const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
-    if (m && ctx.rootDefs[m[1]]) {
+    if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
+      if (ctx.refStack.has(schema.$ref)) return
+      ctx.refStack.add(schema.$ref)
       genCodeE(ctx.rootDefs[m[1]], v, pathExpr, lines, ctx)
+      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)
+      genCodeE(ctx.schemaMap.get(schema.$ref), v, pathExpr, lines, ctx)
+      ctx.refStack.delete(schema.$ref)
+      return
     }
   }
 
@@ -1162,6 +1419,55 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
     }
   }
 
+  // patternProperties
+  if (schema.patternProperties) {
+    for (const [pat, sub] of Object.entries(schema.patternProperties)) {
+      const ri = ctx.varCounter++
+      ctx.helperCode.push(`const _re${ri}=new RegExp(${JSON.stringify(pat)})`)
+      const ki = ctx.varCounter++
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){if(_re${ri}.test(_k${ki})){`)
+      const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
+      genCodeE(sub, `${v}[_k${ki}]`, p, lines, ctx)
+      lines.push(`}}}`)
+    }
+  }
+
+  // dependentSchemas
+  if (schema.dependentSchemas) {
+    for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
+      genCodeE(depSchema, v, pathExpr, lines, ctx)
+      lines.push(`}`)
+    }
+  }
+
+  // propertyNames
+  if (schema.propertyNames && typeof schema.propertyNames === 'object') {
+    const pn = schema.propertyNames
+    const ki = ctx.varCounter++
+    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){`)
+    if (pn.minLength !== undefined) {
+      lines.push(`if(_k${ki}.length<${pn.minLength}){${fail('min_length_violation', `'propertyNames: key too short: '+_k${ki}`)}}`)
+    }
+    if (pn.maxLength !== undefined) {
+      lines.push(`if(_k${ki}.length>${pn.maxLength}){${fail('max_length_violation', `'propertyNames: key too long: '+_k${ki}`)}}`)
+    }
+    if (pn.pattern) {
+      const ri = ctx.varCounter++
+      ctx.helperCode.push(`const _re${ri}=new RegExp(${JSON.stringify(pn.pattern)})`)
+      lines.push(`if(!_re${ri}.test(_k${ki})){${fail('pattern_mismatch', `'propertyNames: pattern mismatch: '+_k${ki}`)}}`)
+    }
+    if (pn.const !== undefined) {
+      lines.push(`if(_k${ki}!==${JSON.stringify(pn.const)}){${fail('const_mismatch', `'propertyNames: expected '+${JSON.stringify(pn.const)}`)}}`)
+    }
+    if (pn.enum) {
+      const ei = ctx.varCounter++
+      ctx.helperCode.push(`const _es${ei}=new Set(${JSON.stringify(pn.enum)})`)
+      lines.push(`if(!_es${ei}.has(_k${ki})){${fail('enum_mismatch', `'propertyNames: key not in enum: '+_k${ki}`)}}`)
+    }
+    lines.push(`}}`)
+  }
+
   // items — starts after prefixItems (Draft 2020-12 semantics)
   if (schema.items) {
     const startIdx = schema.prefixItems ? schema.prefixItems.length : 0
@@ -1265,18 +1571,37 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
 // Returns VALID_RESULT for valid data, {valid:false, errors} for invalid.
 // Avoids double-pass (jsFn → false → errFn runs same checks again).
 // Uses type-aware optimizations: after type check passes, skip guards.
-function compileToJSCombined(schema, VALID_RESULT) {
+function compileToJSCombined(schema, VALID_RESULT, schemaMap) {
   if (typeof schema === 'boolean') {
     return schema
       ? () => VALID_RESULT
       : () => ({ valid: false, errors: [{ code: 'type_mismatch', path: '', message: 'schema is false' }] })
   }
   if (typeof schema !== 'object' || schema === null) return null
-  if (!codegenSafe(schema)) return null
-  if (schema.patternProperties || schema.dependentSchemas || schema.propertyNames) return null
+  if (!codegenSafe(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')
+    if (keys.some(k => !supported.includes(k))) return null
+  }
 
   const ctx = { varCounter: 0, helperCode: [], closureVars: [], closureVals: [],
-                rootDefs: schema.$defs || schema.definitions || null, refStack: new Set() }
+                rootDefs: schema.$defs || schema.definitions || null, refStack: new Set(), schemaMap: schemaMap || null }
   const lines = []
   genCodeC(schema, 'd', '', lines, ctx)
   if (lines.length === 0) return () => VALID_RESULT
@@ -1305,18 +1630,45 @@ function compileToJSCombined(schema, VALID_RESULT) {
 function genCodeC(schema, v, pathExpr, lines, ctx) {
   if (typeof schema !== 'object' || schema === null) return
 
-  // $ref — resolve local refs
-  if (schema.$ref && ctx.rootDefs) {
+  // $ref — resolve local and cross-schema refs
+  if (schema.$ref) {
     const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
-    if (m && ctx.rootDefs[m[1]]) {
+    if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
+      if (ctx.refStack.has(schema.$ref)) return
+      ctx.refStack.add(schema.$ref)
       genCodeC(ctx.rootDefs[m[1]], v, pathExpr, lines, ctx)
+      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)
+      genCodeC(ctx.schemaMap.get(schema.$ref), v, pathExpr, lines, ctx)
+      ctx.refStack.delete(schema.$ref)
+      return
     }
   }
 
   const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null
   let isObj = false, isArr = false, isStr = false, isNum = false
 
-  const fail = (code, msg) => `(_e||(_e=[])).push({code:'${code}',path:${pathExpr||'""'},message:${msg}})`
+  // Pre-allocate error objects as closure variables for static paths.
+  // This shrinks the generated function body → better V8 JIT on valid path.
+  const isStaticPath = !pathExpr || (pathExpr.startsWith("'") && !pathExpr.includes('+'))
+  const fail = (code, msg) => {
+    if (isStaticPath && msg.startsWith("'") && !msg.includes('+')) {
+      // Static error: pre-allocate as frozen closure variable
+      const ei = ctx.varCounter++
+      const errVar = `_E${ei}`
+      const pathVal = pathExpr ? pathExpr.slice(1, -1) : ''
+      const msgVal = msg.slice(1, -1)
+      ctx.closureVars.push(errVar)
+      ctx.closureVals.push(Object.freeze({code, path: pathVal, message: msgVal}))
+      return `(_e||(_e=[])).push(${errVar})`
+    }
+    // Dynamic path (e.g., array index): inline as before
+    return `(_e||(_e=[])).push({code:'${code}',path:${pathExpr||'""'},message:${msg}})`
+  }
 
   if (types) {
     const conds = types.map(t => {
@@ -1391,7 +1743,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
   } else if (schema.required) {
     for (const key of schema.required) {
       const p = pathExpr ? `${pathExpr}+'/${esc(key)}'` : `'/${esc(key)}'`
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){_e.push({code:'required_missing',path:${p},message:'missing: ${esc(key)}'})}`)
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){(_e||(_e=[])).push({code:'required_missing',path:${p},message:'missing: ${esc(key)}'})}`)
     }
   }
 
@@ -1444,8 +1796,8 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
   if (schema.minProperties !== undefined) lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&Object.keys(${v}).length<${schema.minProperties}){${fail('min_properties_violation', `'minProperties ${schema.minProperties}'`)}}`)
   if (schema.maxProperties !== undefined) lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&Object.keys(${v}).length>${schema.maxProperties}){${fail('max_properties_violation', `'maxProperties ${schema.maxProperties}'`)}}`)
 
-  // additionalProperties
-  if (schema.additionalProperties === false && schema.properties) {
+  // additionalProperties — skip if patternProperties present (handled in unified loop below)
+  if (schema.additionalProperties === false && schema.properties && !schema.patternProperties) {
     const allowed = Object.keys(schema.properties).map(k => JSON.stringify(k)).join(',')
     const ci = ctx.varCounter++
     lines.push(isObj
@@ -1485,6 +1837,155 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
     }
   }
 
+  // patternProperties — same optimizations as genCode: charCodeAt + inline key comparison + merged propertyNames
+  if (schema.patternProperties) {
+    const ppEntries = Object.entries(schema.patternProperties)
+    const pn = schema.propertyNames && typeof schema.propertyNames === 'object' ? schema.propertyNames : null
+    const pi = ctx.varCounter++
+
+    // Build pattern matchers: prefer charCodeAt for simple prefixes
+    const matchers = []
+    for (const [pat] of ppEntries) {
+      const kVar = `_k${pi}`
+      const fast = fastPrefixCheck(pat, kVar)
+      if (fast) {
+        matchers.push({ check: fast })
+      } else {
+        const ri = ctx.varCounter++
+        ctx.closureVars.push(`_re${ri}`)
+        ctx.closureVals.push(new RegExp(pat))
+        matchers.push({ check: `_re${ri}.test(_k${pi})` })
+      }
+    }
+
+    // Build sub-schema validators as closure vars
+    for (let i = 0; i < ppEntries.length; i++) {
+      const [, sub] = ppEntries[i]
+      const subLines = []
+      genCode(sub, `_ppv`, subLines, ctx)
+      const fnBody = subLines.length === 0 ? `return true` : `${subLines.join(';')};return true`
+      const fnVar = `_ppf${pi}_${i}`
+      ctx.closureVars.push(fnVar)
+      ctx.closureVals.push(new Function('_ppv', fnBody))
+    }
+
+    const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+    const kVar = `_k${pi}`
+
+    if (schema.additionalProperties === false && schema.properties) {
+      ctx._ppHandledPropertyNamesC = !!pn
+      const propKeys = Object.keys(schema.properties)
+      // Inline key comparison for small property sets
+      const keyCheck = propKeys.length <= 8
+        ? propKeys.map(k => `${kVar}===${JSON.stringify(k)}`).join('||')
+        : null
+      if (!keyCheck) {
+        const allowedSet = `_as${pi}`
+        ctx.closureVars.push(allowedSet)
+        ctx.closureVals.push(new Set(propKeys))
+      }
+
+      lines.push(`${guard}{for(const ${kVar} in ${v}){`)
+      // propertyNames checks (merged)
+      if (pn) {
+        if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength}){${fail('min_length_violation', `'propertyNames: key too short: '+${kVar}`)}}`)
+        if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength}){${fail('max_length_violation', `'propertyNames: key too long: '+${kVar}`)}}`)
+        if (pn.pattern) {
+          const fast = fastPrefixCheck(pn.pattern, kVar)
+          if (fast) {
+            lines.push(`if(!(${fast})){${fail('pattern_mismatch', `'propertyNames: pattern mismatch: '+${kVar}`)}}`)
+          } else {
+            const ri = ctx.varCounter++
+            ctx.closureVars.push(`_re${ri}`)
+            ctx.closureVals.push(new RegExp(pn.pattern))
+            lines.push(`if(!_re${ri}.test(${kVar})){${fail('pattern_mismatch', `'propertyNames: pattern mismatch: '+${kVar}`)}}`)
+          }
+        }
+        if (pn.const !== undefined) lines.push(`if(${kVar}!==${JSON.stringify(pn.const)}){${fail('const_mismatch', `'propertyNames: expected '+${JSON.stringify(pn.const)}`)}}`)
+        if (pn.enum) {
+          const ei = ctx.varCounter++
+          ctx.closureVars.push(`_es${ei}`)
+          ctx.closureVals.push(new Set(pn.enum))
+          lines.push(`if(!_es${ei}.has(${kVar})){${fail('enum_mismatch', `'propertyNames: key not in enum: '+${kVar}`)}}`)
+        }
+      }
+      const matchExpr = keyCheck || `_as${pi}.has(${kVar})`
+      lines.push(`let _m${pi}=${matchExpr}`)
+      for (let i = 0; i < ppEntries.length; i++) {
+        lines.push(`if(${matchers[i].check}){_m${pi}=true;if(!_ppf${pi}_${i}(${v}[${kVar}])){${fail('pattern_mismatch', `'patternProperties: value invalid for key '+${kVar}`)}}}`)
+      }
+      lines.push(`if(!_m${pi}){${fail('additional_property', `'extra: '+${kVar}`)}}`)
+      lines.push(`}}`)
+    } else {
+      ctx._ppHandledPropertyNamesC = !!pn
+      lines.push(`${guard}{for(const ${kVar} in ${v}){`)
+      if (pn) {
+        if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength}){${fail('min_length_violation', `'propertyNames: key too short: '+${kVar}`)}}`)
+        if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength}){${fail('max_length_violation', `'propertyNames: key too long: '+${kVar}`)}}`)
+        if (pn.pattern) {
+          const fast = fastPrefixCheck(pn.pattern, kVar)
+          if (fast) {
+            lines.push(`if(!(${fast})){${fail('pattern_mismatch', `'propertyNames: pattern mismatch: '+${kVar}`)}}`)
+          } else {
+            const ri = ctx.varCounter++
+            ctx.closureVars.push(`_re${ri}`)
+            ctx.closureVals.push(new RegExp(pn.pattern))
+            lines.push(`if(!_re${ri}.test(${kVar})){${fail('pattern_mismatch', `'propertyNames: pattern mismatch: '+${kVar}`)}}`)
+          }
+        }
+        if (pn.const !== undefined) lines.push(`if(${kVar}!==${JSON.stringify(pn.const)}){${fail('const_mismatch', `'propertyNames: expected '+${JSON.stringify(pn.const)}`)}}`)
+        if (pn.enum) {
+          const ei = ctx.varCounter++
+          ctx.closureVars.push(`_es${ei}`)
+          ctx.closureVals.push(new Set(pn.enum))
+          lines.push(`if(!_es${ei}.has(${kVar})){${fail('enum_mismatch', `'propertyNames: key not in enum: '+${kVar}`)}}`)
+        }
+      }
+      for (let i = 0; i < ppEntries.length; i++) {
+        lines.push(`if(${matchers[i].check}&&!_ppf${pi}_${i}(${v}[${kVar}])){${fail('pattern_mismatch', `'patternProperties: value invalid for key '+${kVar}`)}}`)
+      }
+      lines.push(`}}`)
+    }
+  }
+
+  // dependentSchemas
+  if (schema.dependentSchemas) {
+    for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
+      genCodeC(depSchema, v, pathExpr, lines, ctx)
+      lines.push(`}`)
+    }
+  }
+
+  // propertyNames — skip if already merged into patternProperties loop
+  if (schema.propertyNames && typeof schema.propertyNames === 'object' && !ctx._ppHandledPropertyNamesC) {
+    const pn = schema.propertyNames
+    const ki = ctx.varCounter++
+    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){`)
+    if (pn.minLength !== undefined) {
+      lines.push(`if(_k${ki}.length<${pn.minLength}){${fail('min_length_violation', `'propertyNames: key too short: '+_k${ki}`)}}`)
+    }
+    if (pn.maxLength !== undefined) {
+      lines.push(`if(_k${ki}.length>${pn.maxLength}){${fail('max_length_violation', `'propertyNames: key too long: '+_k${ki}`)}}`)
+    }
+    if (pn.pattern) {
+      const ri = ctx.varCounter++
+      ctx.closureVars.push(`_re${ri}`)
+      ctx.closureVals.push(new RegExp(pn.pattern))
+      lines.push(`if(!_re${ri}.test(_k${ki})){${fail('pattern_mismatch', `'propertyNames: pattern mismatch: '+_k${ki}`)}}`)
+    }
+    if (pn.const !== undefined) {
+      lines.push(`if(_k${ki}!==${JSON.stringify(pn.const)}){${fail('const_mismatch', `'propertyNames: expected '+${JSON.stringify(pn.const)}`)}}`)
+    }
+    if (pn.enum) {
+      const ei = ctx.varCounter++
+      ctx.closureVars.push(`_es${ei}`)
+      ctx.closureVals.push(new Set(pn.enum))
+      lines.push(`if(!_es${ei}.has(_k${ki})){${fail('enum_mismatch', `'propertyNames: key not in enum: '+_k${ki}`)}}`)
+    }
+    lines.push(`}}`)
+  }
+
   // items
   if (schema.items) {
     const startIdx = schema.prefixItems ? schema.prefixItems.length : 0