ata-validator 1.43.0 → 1.45.0

package/lib/js-compiler.js

@@ -10,12 +10,20 @@
 // forms answers a different question and costs a string per call.
 const DEQ_HELPER = "function _deq(a,b){if(a===b)return true;if(a===null||b===null||typeof a!=='object'||typeof b!=='object')return false;var aa=Array.isArray(a);if(aa!==Array.isArray(b))return false;var i;if(aa){if(a.length!==b.length)return false;for(i=0;i<a.length;i++)if(!_deq(a[i],b[i]))return false;return true}var ka=Object.keys(a);if(ka.length!==Object.keys(b).length)return false;for(i=0;i<ka.length;i++){var k=ka[i];if(!Object.prototype.hasOwnProperty.call(b,k)||!_deq(a[k],b[k]))return false}return true}"
 
-// uniqueItems helpers for the boolean generator. `_uq` answers whether every
-// item is distinct: short arrays compare pairwise and allocate nothing,
-// longer ones use a Set of primitives and fall back to sorted-key canonical
-// strings only once an object actually appears.
-const UQ_HELPERS = "function _cn(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn(x[k])}).join(',')+'}'}" +
-  "function _uq(a){var n=a.length,i,k;if(n<2)return true;if(n<=12){for(i=1;i<n;i++)for(k=0;k<i;k++)if(_deq(a[i],a[k]))return false;return true}var s=new Set();for(i=0;i<n;i++){var x=a[i];if(x!==null&&typeof x==='object')break;if(s.has(x))return false;s.add(x)}if(i===n)return true;s=new Set();for(i=0;i<n;i++){var c=_cn(a[i]);if(s.has(c))return false;s.add(c)}return true}"
+// uniqueItems helpers, emitted from the functions the interpreted engine
+// calls (lib/unique-items.js): `_uq` answers whether every item is distinct.
+// Loaded at the first schema with uniqueItems, not on every cold start.
+// Comment lines and indentation are dropped: the text lands in every
+// generated function and ahead-of-time module that checks uniqueItems.
+let _uqSources = null
+function uqSources () {
+  if (_uqSources === null) {
+    const u = require('./unique-items')
+    const compact = (fn) => String(fn).replace(/\n\s*\/\/[^\n]*/g, '').replace(/\n\s*/g, '\n')
+    _uqSources = { uq: compact(u._uqh) + compact(u._uq), uqp: 'var _uqpI=0;' + compact(u._uqp) }
+  }
+  return _uqSources
+}
 
 // Where a generator hoists a declaration so it runs once per compiled
 // function rather than once per call. The boolean generator has a preamble
@@ -97,7 +105,7 @@ function emitPtrEsc(ctx) {
 // `_uq` compares items with `_deq`, so it can never be hoisted alone.
 function emitUq(ctx) {
   emitDeq(ctx)
-  hoistOnce(ctx, '_uqHoisted', UQ_HELPERS)
+  hoistOnce(ctx, '_uqHoisted', uqSources().uq)
   return '_uq'
 }
 
@@ -107,15 +115,11 @@ function emitUq(ctx) {
 // a later equal, paired with its first later equal. That is the pair the
 // interpreted engine reports, and the generators used to report a different
 // one (the earliest repeat, paired with what it repeats), so the same document
-// named a different pair depending on the engine that answered. Short arrays
-// compare pairwise and allocate nothing; longer ones key a Map by value, or by
-// canonical string once an object appears. Building a canonical string for
-// every item on every call, as the generators did, made reading a uniqueItems
-// error up to ten times the cost of the verdict.
-const UQP_HELPER = "var _uqpI=0;function _uqp(a){var n=a.length,i,k;if(n<2)return -1;if(n<=12){for(i=0;i<n-1;i++)for(k=i+1;k<n;k++)if(_deq(a[i],a[k])){_uqpI=i;return k}return -1}var prim=true;for(i=0;i<n;i++){var x=a[i];if(x!==null&&typeof x==='object'){prim=false;break}}var m=new Map(),bi=-1,bj=-1;for(i=0;i<n;i++){var c=prim?a[i]:_cn(a[i]);var p=m.get(c);if(p===undefined)m.set(c,i);else if(p>=0){if(bi<0||p<bi){bi=p;bj=i}m.set(c,-1)}}if(bi<0)return -1;_uqpI=bi;return bj}"
+// named a different pair depending on the engine that answered. See
+// lib/unique-items.js for how it finds the pair.
 function emitUqp(ctx) {
   emitUq(ctx)
-  hoistOnce(ctx, '_uqpHoisted', UQP_HELPER)
+  hoistOnce(ctx, '_uqpHoisted', uqSources().uqp)
   return '_uqp'
 }
 
@@ -1065,6 +1069,16 @@ function hasOwnKey (d, key) {
   return _hop.call(d, key)
 }
 
+// Writes an own key. A schema can name a property, a definition or even a
+// keyword "__proto__", and assigning that key sets the copy's prototype
+// instead: the property was gone from the copy, so a constraint on it was
+// generated as nothing and accepted anything (a schema with such a property
+// and a reference the resolver rewrites, 1.40.1 to 1.43.0).
+function setOwn (o, k, v) {
+  if (k === '__proto__') Object.defineProperty(o, k, { value: v, writable: true, enumerable: true, configurable: true })
+  else o[k] = v
+}
+
 const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'toString', 'valueOf',
   'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString'])
 
@@ -1380,7 +1394,7 @@ function aliasChainEnds(def, defs) {
 // source of evaluated properties the schema has; when it does not, the
 // schema is not generated and the interpreter answers.
 function unevalPropsModeled(schema, schemaMap) {
-  const own = Object.assign({}, schema)
+  const own = { ...schema }
   delete own.$defs
   delete own.definitions
   if (/"\$(?:ref|dynamicRef|recursiveRef)"/.test(JSON.stringify(own))) return false
@@ -1399,7 +1413,7 @@ function unevalPropsModeled(schema, schemaMap) {
     if (typeof sub !== 'object' || sub === null) return false
     const r = collectEvaluated(sub, schemaMap)
     if (r.dynamic || r.allProps) return false
-    const rest = Object.assign({}, sub)
+    const rest = { ...sub }
     delete rest.patternProperties
     const j = JSON.stringify(rest)
     if (j.includes('"patternProperties"') || j.includes('"unevaluatedProperties"')) return false
@@ -1432,7 +1446,7 @@ function unevalPropsModeled(schema, schemaMap) {
     if (typeof schema.if !== 'object' || schema.if === null) return false
     const r = collectEvaluated(schema.if, schemaMap)
     if (r.dynamic || r.allProps || r.props.length) return false
-    const rest = Object.assign({}, schema.if)
+    const rest = { ...schema.if }
     delete rest.patternProperties
     const j = JSON.stringify(rest)
     if (j.includes('"patternProperties"') || j.includes('"unevaluatedProperties"')) return false
@@ -1486,17 +1500,7 @@ function codegenSafe(schema, schemaMap) {
   }
 
   // Keys that collide with Object.prototype
-  if (schema.required) {
-    for (const k of schema.required) {
-      if (UNSAFE_KEYS.has(k)) return false
-    }
-  }
-  if (schema.properties) {
-    for (const k of Object.keys(schema.properties)) {
-      if (UNSAFE_KEYS.has(k)) return false
-      if (k === '$ref') return false // property named "$ref" — confusing
-    }
-  }
+
 
   // Unicode property escapes in pattern need 'u' flag — codegen uses RegExp without it
 
@@ -1627,10 +1631,8 @@ function codegenSafe(schema, schemaMap) {
       if (typeof sub === 'object' && sub !== null && !codegenSafe(sub, schemaMap)) return false
     }
   }
-  if (typeof schema.propertyNames === 'object' && schema.propertyNames !== null) {
-    const supported = ['maxLength', 'minLength', 'pattern', 'const', 'enum']
-    if (Object.keys(schema.propertyNames).some(k => k !== '$schema' && !supported.includes(k))) return false
-  }
+  if (typeof schema.propertyNames === 'object' && schema.propertyNames !== null &&
+      !isSimplePN(schema.propertyNames) && !codegenSafe(schema.propertyNames, schemaMap)) return false
 
   // Recurse into sub-schemas — bail on boolean schemas in any position
   // A boolean subschema is a constant that every generator emits at its
@@ -1968,8 +1970,21 @@ function bothDefsContainers(schema) {
     schema.definitions !== null && typeof schema.definitions === 'object'
 }
 
+// The answer depends on the schema and the map alone, and the three
+// generators ask it about the same prepared schema in turn, so the last
+// answer is kept: each check walks the whole schema, and the second and third
+// asked again what the first had found. One entry, compared by identity,
+// because a WeakMap entry per schema cost more than the walk it saved on a
+// small schema that only ever gets its verdict generated.
+let _gateSchema = null, _gateMap = null, _gateOk = false
 function sharedCodegenGate(schema, schemaMap) {
   if (typeof schema !== 'object' || schema === null) return true
+  if (schema === _gateSchema && schemaMap === _gateMap) return _gateOk
+  const ok = sharedCodegenGateUncached(schema, schemaMap)
+  _gateSchema = schema; _gateMap = schemaMap; _gateOk = ok
+  return ok
+}
+function sharedCodegenGateUncached(schema, schemaMap) {
   if (bothDefsContainers(schema)) return false
   if (hasSameInstanceRefCycle(schema)) return false
   if (!codegenSafe(schema, schemaMap)) return false
@@ -1985,6 +2000,15 @@ function sharedCodegenGate(schema, schemaMap) {
 // `type: 'string'` and annotations go, on a copy. Anything else is left as
 // written and the gate declines. Errors keep the interpreted engine's path.
 const PN_SUPPORTED = new Set(['maxLength', 'minLength', 'pattern', 'const', 'enum'])
+// Whether the generators can write `propertyNames` as checks on the key in the
+// object's own key loop. Any other subschema is applied to each key as a
+// value of its own (genPropertyNamesNode and its error and combined
+// counterparts), which is what the interpreter does.
+function isSimplePN (pn) {
+  if (pn === null || typeof pn !== 'object' || Array.isArray(pn)) return false
+  for (const k of Object.keys(pn)) if (k !== '$schema' && !PN_SUPPORTED.has(k)) return false
+  return true
+}
 const PN_ANNOTATIONS = new Set(['$schema', '$comment', 'title', 'description', 'examples', 'default', 'deprecated', 'readOnly', 'writeOnly'])
 function simplePropertyNames(pn, defs) {
   const seen = new Set()
@@ -2006,7 +2030,7 @@ function simplePropertyNames(pn, defs) {
       return null
     }
     if (!PN_SUPPORTED.has(k)) return null
-    out[k] = val
+    setOwn(out, k, val)
   }
   return out
 }
@@ -2037,14 +2061,14 @@ function normalizePropertyNamesWalk(root) {
       return out
     }
     let out = node
-    const set = (k, v) => { if (out === node) out = { ...node }; out[k] = v }
+    const set = (k, v) => { if (out === node) out = { ...node }; setOwn(out, k, v) }
     for (const k of SUBSCHEMA_MAPS) {
       const map = node[k]
       if (!map || typeof map !== 'object') continue
       let copy = map
       for (const [name, sub] of Object.entries(map)) {
         const w = walk(sub)
-        if (w !== sub) { if (copy === map) copy = { ...map }; copy[name] = w }
+        if (w !== sub) { if (copy === map) copy = { ...map }; setOwn(copy, name, w) }
       }
       if (copy !== map) set(k, copy)
     }
@@ -2162,7 +2186,7 @@ function normalizeDeepRefsWalk(root) {
     if (inner) return node
     let out = node
     memo.set(node, out)
-    const own = (k, v) => { if (out === node) { out = { ...node }; memo.set(node, out) } out[k] = v }
+    const own = (k, v) => { if (out === node) { out = { ...node }; memo.set(node, out) } setOwn(out, k, v) }
     if (typeof node.$ref === 'string' && names.has(node.$ref)) own('$ref', '#/' + defsKey + '/' + names.get(node.$ref))
     for (const k of Object.keys(node)) {
       if (k === '$ref' || k === 'enum' || k === 'const' || k === 'default' || k === 'examples') continue
@@ -2211,10 +2235,39 @@ function normalizeRefs(root, schemaMap) {
   return out
 }
 const SKIP_VALUE_KEYS = new Set(['enum', 'const', 'default', 'examples'])
+// A schema whose every reference is `#` or a plain `#/$defs/name` (or
+// `definitions`), with no `$id` or `$anchor` below the root to move the base
+// they resolve against, needs nothing from the resolver: each reference
+// already reads as the generators read it. Telling that from the text skips
+// loading the interpreted engine and indexing the schema, which was most of
+// what preparing a small schema for code generation cost.
+const LOCAL_ONLY_REF = /^#(?:\/(?:\$defs|definitions)\/[^/~%]+)?$/
+function refsAllPlainLocal (root, text) {
+  const ids = text.split('"$id":').length - 1
+  if (ids > (typeof root.$id === 'string' ? 1 : 0) || text.includes('"$anchor":')) return false
+  const re = /"\$ref":("(?:[^"\\]|\\.)*")/g
+  let m
+  while ((m = re.exec(text)) !== null) {
+    let ref
+    try { ref = JSON.parse(m[1]) } catch { return false }
+    if (!LOCAL_ONLY_REF.test(ref)) return false
+  }
+  return true
+}
+
+// What the text of a schema prepared for code generation says about its size,
+// kept from the stringify normalizeRefsWalk makes anyway: its length when it
+// holds no `$ref`, -1 when it does. expandedChars counts at most 8 for each
+// character of a schema without references, so a short one is known not to
+// reach EXPANDED_SHARE without walking it again at every compile.
+const _refFreeLength = new WeakMap()
 function normalizeRefsWalk(root, schemaMap) {
   const text = JSON.stringify(root)
-  if (!text.includes('"$ref"')) return root
+  const hasRef = text.includes('"$ref"')
+  _refFreeLength.set(root, hasRef ? -1 : text.length)
+  if (!hasRef) return root
   if (/"\$(?:dynamicRef|recursiveRef|dynamicAnchor|recursiveAnchor)"/.test(text)) return null
+  if (refsAllPlainLocal(root, text)) return root
   const { indexSchemas, resolveRef } = require('./interpreter')._refInternals
   const state = indexSchemas(root, schemaMap && schemaMap.size ? schemaMap : null)
   const rootDialect = typeof root.$schema === 'string' ? root.$schema.replace(/#$/, '') : null
@@ -2280,7 +2333,7 @@ function normalizeRefsWalk(root, schemaMap) {
         out.$ref = t === root ? '#' : '#/' + defsKey + '/' + names.get(t)
         continue
       }
-      out[k] = SKIP_VALUE_KEYS.has(k) ? node[k] : walk(node[k])
+      setOwn(out, k, SKIP_VALUE_KEYS.has(k) ? node[k] : walk(node[k]))
     }
     return out
   }
@@ -2299,6 +2352,46 @@ function prepareForCodegen(schema, schemaMap) {
 }
 
 const VERDICT_SPLIT = 64 * 1024
+// The schema's size with every local reference followed, each definition
+// sized once, annotations left out. A rough measure of the expanded verdict
+// source: on SchemaStore that runs about 1.4 times it at the median, and far
+// less where allOf merges. Past EXPANDED_SHARE the verdict is generated with
+// shared definitions from the start, instead of expanded first and thrown
+// away: SARIF comes to 2.1 million, and generating its 2.8 MB of expanded
+// source only to discard it was most of a cold first validate() (70 ms of the
+// 87 a command line run took to report one error). The bound is set where
+// only schemas that split anyway reach it: SARIF 2.1 measures about 706
+// thousand, while utcm-monitor (370 thousand) and accelerator (262 thousand)
+// stay expanded and keep their speed.
+const EXPANDED_SHARE = 400 * 1024
+const SIZE_SKIPS = new Set(['$defs', 'definitions', 'description', 'title', 'examples', 'default', '$comment', 'markdownDescription', 'deprecated', 'readOnly', 'writeOnly'])
+function expandedChars (root, limit) {
+  const defs = (root && (root.$defs || root.definitions)) || {}
+  const memo = new Map()
+  const size = (n, stack) => {
+    if (n === null || typeof n !== 'object') return 8
+    let t = 2
+    if (Array.isArray(n)) { for (const x of n) { t += size(x, stack) + 1; if (t > limit) return t } return t }
+    for (const k of Object.keys(n)) {
+      if (SIZE_SKIPS.has(k)) continue
+      const v = n[k]
+      if (k === '$ref' && typeof v === 'string') {
+        const m = /^#\/(?:\$defs|definitions)\/([^/]+)$/.exec(v)
+        if (m && defs[m[1]] !== undefined && !stack.has(m[1])) {
+          let d = memo.get(m[1])
+          if (d === undefined) { stack.add(m[1]); d = size(defs[m[1]], stack); stack.delete(m[1]); memo.set(m[1], d) }
+          t += d
+          if (t > limit) return t
+          continue
+        }
+      }
+      t += k.length + 3 + size(v, stack)
+      if (t > limit) return t
+    }
+    return t
+  }
+  return size(root, new Set())
+}
 function sourceSize (lines, ctx) {
   let n = 0
   for (const l of lines) n += l.length
@@ -2340,13 +2433,7 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
       if (typeof sub === 'object' && sub !== null && !codegenSafe(sub, schemaMap)) return null
     }
   }
-  // propertyNames: only codegen simple string constraints
-  if (schema.propertyNames) {
-    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
-  }
+  if (schema.propertyNames && typeof schema.propertyNames === 'object' && !isSimplePN(schema.propertyNames) && !codegenSafe(schema.propertyNames, schemaMap)) return null
 
   // Build anchors map for $ref/#anchor and $dynamicRef resolution
   const anchors = {}
@@ -2389,7 +2476,11 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
   // (79 KB of schema) came to 2.8 MB of verdict source, and compiling it was
   // half of the first validate() call.
   let ctx, lines
-  for (const share of [false, true]) {
+  const refFree = _refFreeLength.get(inputSchema)
+  const shareFirst = refFree !== undefined && refFree >= 0 && refFree * 8 <= EXPANDED_SHARE
+    ? false
+    : expandedChars(schema, EXPANDED_SHARE) > EXPANDED_SHARE
+  for (const share of shareFirst ? [true] : [false, true]) {
     ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: inputSchema, userFormats: userFormats || null, removeNodes,
       keywords: (opts && opts.keywords) || null, kwEmitted: null, shareDefs: share }
     if (ctx.keywords) ctx.kwEmitted = new Set()
@@ -3394,6 +3485,10 @@ function genUniqueItemsNode(schema, v, lines, ctx, knownType, hoisted, isArr, ty
     // up. The previous form built the canonical closure and a Set on
     // every call, even for [1, 2, 3].
     inner = `if(!${emitUq(ctx)}(${v}))return false`
+  } else if (ctx.helperCode) {
+    // Inside the error or combined function, whose helper code is emitted
+    // into its source, the same hoisted helper.
+    inner = `if(!${emitUq(ctx)}(${v}))return false`
   } else {
     inner = `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);if(_s${si}.has(_k))return false;_s${si}.add(_k)}`
   }
@@ -3438,6 +3533,13 @@ function genPropertyNamesNode(schema, v, lines, ctx, knownType, isObj) {
   const pn = schema.propertyNames
   const ki = ctx.varCounter++
   const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+  if (!isSimplePN(pn)) {
+    const sub = []
+    genCode(pn, '_pv', sub, ctx)
+    if (sub.length === 0) return
+    lines.push(`${guard}{const _pnf${ki}=function(_pv){${sub.join(';')};return true};for(const _k${ki} in ${v}){if(!_pnf${ki}(_k${ki}))return false}}`)
+    return
+  }
   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`)
@@ -3760,7 +3862,7 @@ function genRefNode(schema, v, lines, ctx, knownType, hasSiblings) {
 function genPatternPropertiesNode(schema, v, lines, ctx, knownType, isObj) {
   let handledPropertyNames = false
   const ppEntries = Object.entries(schema.patternProperties)
-  const pn = schema.propertyNames && typeof schema.propertyNames === 'object' ? schema.propertyNames : null
+  const pn = isSimplePN(schema.propertyNames) ? schema.propertyNames : null
   const pi = ctx.varCounter++
   const kVar = `_ppk${pi}`
 
@@ -4821,12 +4923,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
       if (typeof sub === 'object' && sub !== null && !codegenSafe(sub, schemaMap)) return null
     }
   }
-  if (schema.propertyNames) {
-    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
-  }
+  if (schema.propertyNames && typeof schema.propertyNames === 'object' && !isSimplePN(schema.propertyNames) && !codegenSafe(schema.propertyNames, schemaMap)) return null
 
   // Build anchors map for $ref/#anchor and $dynamicRef resolution
   const eRootDefs = schema.$defs || schema.definitions || null
@@ -5114,7 +5211,7 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
   // In the combined function `_e` is created on the first error and every
   // error is collected (`_all` is true there), so the report only pushes.
   const report = ctx.inCombined && !ctx.inBranchFn
-    ? `const ${collapsed}=__ataCollapse('${branchKw}',${resArr},_pp${fi},'${branchSp}',${ord},_bt${fi});if(${collapsed})(_e||(_e=[])).push(${collapsed})`
+    ? `const ${collapsed}=__ataCollapse('${branchKw}',${resArr},_pp${fi},'${branchSp}',${ord},_bt${fi});if(${collapsed})(_e=_ap(_e,${collapsed}))`
     : `const ${collapsed}=__ataCollapse('${branchKw}',${resArr},_pp${fi},'${branchSp}',${ord},_bt${fi});if(${collapsed}){_e.push(${collapsed});if(!_all)return{valid:false,errors:_e}}`
   // The node's runtime unevaluatedProperties already counted how many of
   // these branches pass, through the annotation functions, which answer the
@@ -5130,7 +5227,7 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
   // branch errors, so it is built from the bits the count left.
   if (guard !== '' && keyword === 'oneOf' && counted.mask && ctx.inCombined && !ctx.inBranchFn) {
     const ord0 = ctx.noOrdinal ? 'null' : (() => { const o = ordinalFor(ctx.rootSchema, unescapeSp(branchSp)); return o === null ? 'null' : o })()
-    guard = `if(${same}&&${counted.count}>1){const _pi${fi}=[];for(let _k=0;_k<${branches.length};_k++)if((${counted.mask}>>_k)&1)_pi${fi}.push(_k);(_e||(_e=[])).push(__ataMulti(_pi${fi},${branches.length},${pp},'${branchSp}',${ord0}))}else if(!(${same}&&${counted.count}===1))`
+    guard = `if(${same}&&${counted.count}>1){const _pi${fi}=[];for(let _k=0;_k<${branches.length};_k++)if((${counted.mask}>>_k)&1)_pi${fi}.push(_k);(_e=_ap(_e,__ataMulti(_pi${fi},${branches.length},${pp},'${branchSp}',${ord0})))}else if(!(${same}&&${counted.count}===1))`
   }
   // Without such a count, each branch also gets a verdict function, and the
   // passing branches are counted with those: a oneOf with exactly one and an
@@ -5191,7 +5288,7 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
         ? `const _pi${fi}=[];for(let _k=0;_k<${L};_k++)if((_m${fi}>>_k)&1)_pi${fi}.push(_k);`
         : ''
       const multi = `__ataMulti(_pi${fi},${L},_pp${fi},'${branchSp}',${ord})`
-      const pushMulti = top ? `(_e||(_e=[])).push(${multi})` : `_e.push(${multi});if(!_all)return{valid:false,errors:_e}`
+      const pushMulti = top ? `(_e=_ap(_e,${multi}))` : `_e.push(${multi});if(!_all)return{valid:false,errors:_e}`
       const count = tests.map((t, i) => `if(${t}){_n${fi}++;${mk ? `_m${fi}|=${1 << i}` : `_pi${fi}.push(${i})`}}`).join('')
       lines.push(`{const _pp${fi}=${pp};let _n${fi}=0${mk ? `,_m${fi}=0` : `,_pi${fi}=[]`};${count}if(_n${fi}!==1){if(_all===0){_e.push(null);return{valid:false,errors:_e}}if(_n${fi}>1){${collect}${pushMulti}}else{const ${resArr}=[];for(let _bi=0;_bi<${L};_bi++)${resArr}.push(${call});${report}}}}`)
     }
@@ -5791,6 +5888,13 @@ function genPropertyNamesE(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
   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}){`)
+  // The subschema checks the key as a value, and its errors are reported at
+  // the object, as the interpreter reports them.
+  if (!isSimplePN(pn)) {
+    genCodeE(pn, `_k${ki}`, pathExpr, lines, ctx, schemaPrefix + '/propertyNames')
+    lines.push(`}}`)
+    return
+  }
   if (pn.minLength !== undefined) {
     lines.push(`if(_k${ki}.length<${pn.minLength}){${fail('minLength', 'propertyNames/minLength', `{limit:${pn.minLength}}`, `'must NOT have fewer than ${pn.minLength} characters'`)}}`)
   }
@@ -5916,7 +6020,7 @@ function sharedErr (lit, rootSchema) {
 // the document. `paramsShared` names a frozen params object hoisted for a
 // static site, so a static error's params stay one shared object as before.
 function errPushC(ctx, keyword, sp, pathExpr, paramsCode, msgCode, valueExpr, lean, paramsShared) {
-  if (!ctx.rich) return `(_e||(_e=[])).push(${lean})`
+  if (!ctx.rich) return `(_e=_ap(_e,${lean}))`
   if (!ctx.richMk) {
     ctx.richMk = true
     const { makeRich } = require('./enrich-site')
@@ -5932,7 +6036,7 @@ function errPushC(ctx, keyword, sp, pathExpr, paramsCode, msgCode, valueExpr, le
   // the definition and the reference's own comes in as `_sp`.
   const rel = sp.startsWith(SP_PLACEHOLDER)
   ctx.closureVals.push(errorSite(keyword, unescapeSp(rel ? sp.slice(SP_PLACEHOLDER.length) : sp), paramsVal, fmt))
-  return `(_e||(_e=[])).push(_mk(${siteVar},${pathExpr || '""'},${paramsShared || paramsCode},${msgCode},${valueExpr},d${rel ? ',_sp' : ''}))`
+  return `(_e=_ap(_e,_mk(${siteVar},${pathExpr || '""'},${paramsShared || paramsCode},${msgCode},${valueExpr},d${rel ? ',_sp' : ''})))`
 }
 
 function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts) {
@@ -5978,12 +6082,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
       if (typeof sub === 'object' && sub !== null && !codegenSafe(sub, schemaMap)) return null
     }
   }
-  if (schema.propertyNames) {
-    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
-  }
+  if (schema.propertyNames && typeof schema.propertyNames === 'object' && !isSimplePN(schema.propertyNames) && !codegenSafe(schema.propertyNames, schemaMap)) return null
 
   // Build anchors map for $ref/#anchor and $dynamicRef resolution
   const cRootDefs = schema.$defs || schema.definitions || null
@@ -6019,7 +6118,11 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
   // runtimeShape: errors without the ordinal, see compileToJSCodegenWithErrors.
-  const ctx = { noOrdinal: !!(opts && opts.runtimeShape), rich: !!(opts && opts.rich), inCombined: true, hoisted: [], rootC: schema, varCounter: 0, helperCode: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
+  // `_ap` adds an error to a list that may not exist yet: the first one
+  // creates it as a one-element literal. Pushing onto an empty `[]` grew its
+  // backing store on every rejection, about 7% of reading errors across the
+  // official suite.
+  const ctx = { noOrdinal: !!(opts && opts.runtimeShape), rich: !!(opts && opts.rich), inCombined: true, hoisted: [], rootC: schema, varCounter: 0, helperCode: ['function _ap(e,x){if(e===undefined)return[x];e.push(x);return e}'], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
                 rootDefs: cRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: cAnchors, rootSchema: inputSchema, userFormats: userFormats || null }
   const lines = []
   try {
@@ -6135,7 +6238,7 @@ function typeMismatchRest(schema, types) {
   for (const k of Object.keys(schema)) {
     if (drop.has(k)) continue
     if (rest === null) rest = {}
-    rest[k] = schema[k]
+    setOwn(rest, k, schema[k])
   }
   if (rest === null) return null
   // A node whose reference was already written (genCodeCNode) keeps that
@@ -6182,6 +6285,14 @@ function emitDefFnC(key, target, cyclic, v, pathExpr, lines, ctx, schemaPrefix)
     ctx.defFnsC.set(key, fnName)
     const outerHoisted = ctx.hoisted
     ctx.hoisted = []
+    // The body is a function of its own: a reference the caller was in the
+    // middle of expanding is not on the stack inside it, where reaching it
+    // again is a call (this function, or another one) rather than a loop.
+    // With the caller's stack, a definition expanded once on the way into
+    // the root's function was taken for a cycle inside it, and the schema
+    // (a tree whose nodes hold trees) lost its one-pass function.
+    const outerRefs = ctx.refStack
+    ctx.refStack = new Set()
     const bodyLines = []
     let hoisted
     try {
@@ -6189,6 +6300,7 @@ function emitDefFnC(key, target, cyclic, v, pathExpr, lines, ctx, schemaPrefix)
     } finally {
       hoisted = ctx.hoisted
       ctx.hoisted = outerHoisted
+      ctx.refStack = outerRefs
     }
     let body = bodyLines.join('\n  ')
     body = body.split(`'${SP_PLACEHOLDER}`).join(`_sp+'`).split(`"${SP_PLACEHOLDER}`).join(`_sp+"`)
@@ -6236,7 +6348,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (Object.keys(schema).some((k) => !REF_NEUTRAL_SIBLINGS.has(k) && !k.startsWith('x-'))) {
       if (!ctx.inCombined || ctx.inBranchFn) throw DECLINE
       genCodeCNode({ $ref: schema.$ref }, v, pathExpr, lines, ctx, schemaPrefix)
-      const rest = Object.assign({}, schema)
+      const rest = { ...schema }
       Object.defineProperty(rest, REF_DONE, { value: true })
       genCodeCNode(rest, v, pathExpr, lines, ctx, schemaPrefix)
       return
@@ -6347,12 +6459,12 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         const lit = {keyword, instancePath: pathVal, schemaPath: spVal, params: Object.freeze(paramsVal), message: msgVal}
         if (o !== null) lit._o = o
         ctx.closureVals.push(sharedErr(lit, ctx.rootSchema))
-        return `(_e||(_e=[])).push(${errVar})`
+        return `(_e=_ap(_e,${errVar}))`
         }
       }
     }
     // Dynamic path (e.g., array index): inline as before
-    return `(_e||(_e=[])).push({keyword:'${keyword}',instancePath:${pathExpr||'""'},schemaPath:'${sp}',params:${paramsCode},message:${msgCode}${ordinalField(ctx, sp)}})`
+    return `(_e=_ap(_e,{keyword:'${keyword}',instancePath:${pathExpr||'""'},schemaPath:'${sp}',params:${paramsCode},message:${msgCode}${ordinalField(ctx, sp)}}))`
   }
 
   // enum and const apply to a value of any type, so a value that fails
@@ -6442,7 +6554,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         const pathVal = pathExpr ? literalValue(pathExpr) : ''
         ctx.closureVars.push(errVar)
         ctx.closureVals.push(sharedErr({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/required`), params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}, ctx.rootSchema))
-        lines.push(`if(${check}){(_e||(_e=[])).push(${errVar})}`)
+        lines.push(`if(${check}){(_e=_ap(_e,${errVar}))}`)
       } else {
         lines.push(`if(${check}){${errPushC(ctx, 'required', `${schemaPrefix}/required`, pathExpr, `{missingProperty:'${esc(key)}'}`, `"must have required property '${esc(key)}'"`, v, `{keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"}`)}}`)
       }
@@ -6456,7 +6568,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         const pathVal = pathExpr ? literalValue(pathExpr) : ''
         ctx.closureVars.push(errVar)
         ctx.closureVals.push(sharedErr({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/required`), params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}, ctx.rootSchema))
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){(_e||(_e=[])).push(${errVar})}`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){(_e=_ap(_e,${errVar}))}`)
       } else {
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){${errPushC(ctx, 'required', `${schemaPrefix}/required`, pathExpr, `{missingProperty:'${esc(key)}'}`, `"must have required property '${esc(key)}'"`, v, `{keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"}`)}}`)
       }
@@ -6608,7 +6720,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
           const pathVal = pathExpr ? literalValue(pathExpr) : ''
           ctx.closureVars.push(errVar)
           ctx.closureVals.push(sharedErr({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/dependentRequired`), params: Object.freeze({missingProperty: dep}), message: `must have required property '${dep}'`}, ctx.rootSchema))
-          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}&&!${ownKeyExpr(ctx, v, dep)}){(_e||(_e=[])).push(${errVar})}`)
+          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}&&!${ownKeyExpr(ctx, v, dep)}){(_e=_ap(_e,${errVar}))}`)
         } else {
           lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}&&!${ownKeyExpr(ctx, v, dep)}){${errPushC(ctx, 'required', `${schemaPrefix}/dependentRequired`, pathExpr, `{missingProperty:'${esc(dep)}'}`, `"must have required property '${esc(dep)}'"`, v, `{keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/dependentRequired'${ordinalField(ctx, `${schemaPrefix}/dependentRequired`)},params:{missingProperty:'${esc(dep)}'},message:"must have required property '${esc(dep)}'"}`)}}`)
         }
@@ -6905,7 +7017,7 @@ function emitAnnot(sub, ctx) {
   ctx.annFns.set(sub, null)
   const name = `_an${ctx.varCounter++}`
   const local = {}
-  for (const k of Object.keys(sub)) if (!ANNOT_APPLICATORS.has(k)) local[k] = sub[k]
+  for (const k of Object.keys(sub)) if (!ANNOT_APPLICATORS.has(k)) setOwn(local, k, sub[k])
   const vl = []
   nestedGenCode(local, '_av', vl, ctx)
   const decls = [`function ${name}_v(_av){${vl.join('\n  ')}\n  return true}`]
@@ -7053,7 +7165,7 @@ function emitAnnotI(sub, ctx) {
   annItemHelpers(ctx)
   const name = `_ai${ctx.varCounter++}`
   const local = {}
-  for (const k of Object.keys(sub)) if (!ANNOT_ITEM_APPLICATORS.has(k)) local[k] = sub[k]
+  for (const k of Object.keys(sub)) if (!ANNOT_ITEM_APPLICATORS.has(k)) setOwn(local, k, sub[k])
   const vl = []
   nestedGenCode(local, '_av', vl, ctx)
   const decls = [`function ${name}_v(_av){${vl.join('\n  ')}\n  return true}`]
@@ -7169,7 +7281,7 @@ function genAdditionalSchemaC(schema, v, pathExpr, lines, ctx, schemaPrefix, isO
 function genPatternPropertiesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj) {
   let handledPropertyNames = false
   const ppEntries = Object.entries(schema.patternProperties)
-  const pn = schema.propertyNames && typeof schema.propertyNames === 'object' ? schema.propertyNames : null
+  const pn = isSimplePN(schema.propertyNames) ? schema.propertyNames : null
   const pi = ctx.varCounter++
 
   // Build pattern matchers: prefer charCodeAt for simple prefixes
@@ -7290,7 +7402,16 @@ function genPropertyNamesFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 function genPropertyNamesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
   const pn = schema.propertyNames
   const ki = ctx.varCounter++
+  // In the rich function an error carries the value it was raised on, and
+  // here that would be the key where the interpreter's error points at the
+  // object, so that one is left to the plain function and enrichment.
+  if (!isSimplePN(pn) && ctx.rich) throw DECLINE
   lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){`)
+  if (!isSimplePN(pn)) {
+    genCodeC(pn, `_k${ki}`, pathExpr, lines, ctx, schemaPrefix + '/propertyNames')
+    lines.push(`}}`)
+    return
+  }
   if (pn.minLength !== undefined) {
     lines.push(`if(_k${ki}.length<${pn.minLength}){${fail('minLength', 'propertyNames/minLength', `{limit:${pn.minLength}}`, `'must NOT have fewer than ${pn.minLength} characters'`)}}`)
   }
@@ -7508,6 +7629,6 @@ function _collectEval(schema, result, defs, schemaMap, refStack, isRoot) {
   // not → contributes nothing (spec: annotations from not are discarded)
 }
 
-module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined, collectEvaluated, unevalContributions, AJV_MESSAGES, _setCodeBudget }
+module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined, collectEvaluated, unevalContributions, expandedChars, AJV_MESSAGES, _setCodeBudget }
 // For tests/test_custom_keyword_codegen.js, which holds these copies to the interpreter's.
 Object.defineProperty(module.exports, '_kwTypeBits', { value: { kwTypeBit, kwDataBits, KW_T_ANY }, enumerable: false })