ata-validator 1.53.0 → 1.55.0

package/lib/js-compiler.js

@@ -1,5 +1,14 @@
 'use strict'
 const { compileFunction } = require('./compile-fn')
+// A comment that differs at every compile, put in front of every program
+// built at run time. V8 keeps one compiled function per source text of a
+// `new Function` call, with one feedback vector: two schemas that generate
+// the same code (two copies of a record schema under different `$id`s) then
+// shared their inline caches, and each other's data shapes, so both ran
+// megamorphic. The emitted (standalone) sources carry no tag, so a build is
+// the same text every time.
+let _compileSeq = 0
+const seqTag = () => `/*${++_compileSeq}*/`
 
 // uniqueItems helpers for the boolean generator, hoisted once per compiled
 // function (and carried into standalone output through the preamble).
@@ -9,7 +18,7 @@ const { compileFunction } = require('./compile-fn')
 // `enum` compare instances by value: two objects with the same members are
 // equal whatever order their keys were written in. Comparing serialized
 // 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}"
+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,k,x,y;if(aa){if(a.length!==b.length)return false;for(i=a.length;i--!==0;)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=ka.length;i--!==0;){k=ka[i];if(!Object.prototype.hasOwnProperty.call(b,k))return false;x=a[k];y=b[k];if(x!==y&&(x===null||y===null||typeof x!=='object'||typeof y!=='object'))return false}for(i=ka.length;i--!==0;){k=ka[i];x=a[k];if(x!==null&&typeof x==='object'&&!_deq(x,b[k]))return false}return true}"
 
 // uniqueItems helpers, emitted from the functions the interpreted engine
 // calls (lib/unique-items.js): `_uq` answers whether every item is distinct.
@@ -152,7 +161,26 @@ function enumOperand(ctx, vals, v, lines) {
 
 // One `enum` test: primitives compare with `===`, which needs no call, and
 // object members go through structural equality.
+// An enum of 64 or more strings is a Set in the preamble, looked up once: the
+// chain of comparisons grows with the list and the lookup does not. Below
+// that the chain wins on real documents, whose values tend to sit early in
+// the list: on SchemaStore's samples a Set made jscsrc (62 values) 16%
+// slower and bigquery-table (18) 19% slower, while from 77 values up it
+// made every schema faster (chrome-manifest 77, tsconfig 108, jscpd 224 at
+// 6x, cryproj 2461 at 28x).
+const ENUM_SET_MIN = 64
 function enumCondition(ctx, vals, v) {
+  if (vals.length >= ENUM_SET_MIN && ctx && Array.isArray(ctx.preamble) && vals.every((x) => typeof x === 'string')) {
+    if (!ctx.enumSets) ctx.enumSets = new Map()
+    const key = JSON.stringify(vals)
+    let name = ctx.enumSets.get(key)
+    if (name === undefined) {
+      name = '_es' + ctx.varCounter++
+      ctx.enumSets.set(key, name)
+      hoist(ctx, `const ${name}=new Set(${key})`)
+    }
+    return `${name}.has(${v})`
+  }
   const parts = []
   const prims = vals.filter((x) => x === null || typeof x !== 'object')
   const objs = vals.filter((x) => x !== null && typeof x === 'object')
@@ -365,7 +393,7 @@ function compileToJS(schema, defs, schemaMap) {
   // required applies to objects only; other types are ignored.
   if (schema.required && Array.isArray(schema.required)) {
     for (const key of schema.required) {
-      checks.push((d) => typeof d !== 'object' || d === null || Array.isArray(d) || hasOwnKey(d, key))
+      checks.push((d) => typeof d !== 'object' || d === null || Array.isArray(d) || (hasOwnKey(d, key) && d[key] !== undefined))
     }
   }
 
@@ -541,7 +569,7 @@ function compileToJS(schema, defs, schemaMap) {
   // format — hand-written fast checks. A format the code generator asserts
   // but this path cannot is a decline, not a pass.
   if (schema.format) {
-    const fc = FORMAT_CHECKS[schema.format]
+    const fc = formatChecks()[schema.format]
     if (fc) checks.push((d) => typeof d !== 'string' || fc(d))
     else if (FORMAT_CODEGEN[schema.format]) return null
   }
@@ -839,14 +867,26 @@ function _canonical(x) {
 // schema with a `format` is compiled; loading it with this module cost every
 // process 0.8 ms of its cold start.
 let _formatsCache = null
-function getFormats () { return _formatsCache || (_formatsCache = { ...require('./formats'), ...require('./formats-source') }) }
+// The format source generators, and the few runtime values from
+// lib/formats.js they are written with, read from that file on first use.
+function getFormats () {
+  if (_formatsCache !== null) return _formatsCache
+  const out = { ...require('./formats-source') }
+  for (const k of ['IPV4', 'IPV6_FULL', 'ipv4Range']) Object.defineProperty(out, k, { get: () => require('./formats')[k], enumerable: true })
+  return (_formatsCache = out)
+}
 // The closure path's formats. It carried its own idea of an email and knew
 // five formats in all, so a schema that reached it was told "valid" for
 // anything the other engines turned away; the first call on a fresh validator
 // is the one that lands here. Every entry now names the same function the
 // other two paths use, and the list is the list they implement.
-const _fmtFns = require('./formats')
-const FORMAT_CHECKS = {
+// Built on first use: lib/formats.js loads only for a schema with a format
+// this path checks, not with the compiler.
+let _formatChecks = null
+function formatChecks () {
+  if (_formatChecks !== null) return _formatChecks
+  const _fmtFns = require('./formats')
+  _formatChecks = {
   email: _fmtFns.email,
   'idn-email': _fmtFns.idnEmail,
   date: _fmtFns.date,
@@ -865,6 +905,8 @@ const FORMAT_CHECKS = {
   'json-pointer': _fmtFns.jsonPointer,
   'relative-json-pointer': _fmtFns.relativeJsonPointer,
   regex: (s) => { try { new RegExp(s, 'u'); return true } catch { return false } },
+  }
+  return _formatChecks
 }
 
 // Dangerous JS property names that exist on Object.prototype
@@ -1238,6 +1280,51 @@ function emitPropFn (prop, ctx) {
   hoist(ctx, `function ${fnName}(d){${bodyLines.join('\n  ')}\n  return true}`)
   return fnName
 }
+// An array's item schema that gets two item functions (see the items case in
+// genCodeNode): an object of many optional properties and nothing else that
+// reads keys. 32 or more optional properties, no names on Object.prototype
+// (the key loop reads `v[k]`, which for `__proto__` is not the data), and no
+// keyword that needs every key or the evaluated set.
+const KEY_LOOP_MIN = 32
+const KEY_LOOP_KEYS = new Set(['type', 'properties', 'required', 'title', 'description', '$comment', 'examples', 'default', 'deprecated', 'readOnly', 'writeOnly'])
+function keyLoopEligible (item) {
+  if (item === null || typeof item !== 'object' || Array.isArray(item) || item.type !== 'object') return false
+  const props = item.properties
+  if (props === null || typeof props !== 'object' || Array.isArray(props)) return false
+  for (const k of Object.keys(item)) if (!KEY_LOOP_KEYS.has(k)) return false
+  const req = new Set(Array.isArray(item.required) ? item.required : [])
+  let optional = 0
+  for (const k of Object.keys(props)) {
+    if (PROTO_NAMES.has(k) || k === '__proto__') return false
+    if (!req.has(k)) optional++
+  }
+  return optional >= KEY_LOOP_MIN
+}
+// Whether two values list the same keys in the same order, which objects of
+// one shape do. Anything that is not two objects counts as alike.
+const SAME_KEYS_HELPER = 'function _sameKeys(a,b){if(a===null||b===null||typeof a!==\'object\'||typeof b!==\'object\')return true;const ka=[];for(const k in a)ka.push(k);let i=0;for(const k in b){if(ka[i++]!==k)return false}return i===ka.length}'
+// One item function: the schema's ordinary code, or (keyLoop) the same with
+// its optional properties checked from the item's own keys. Null when either
+// cannot be written as a function of its own.
+function emitItemFn (item, ctx, keyLoop) {
+  if (!ctx.preamble) return null
+  const bodyLines = []
+  const outerDeferred = ctx.deferredChecks
+  ctx.deferredChecks = null
+  const outerReuse = ctx.plainReuse
+  ctx.plainReuse = undefined
+  const outerBytes = ctx.fnBytes
+  ctx.fnBytes = 0
+  const outerNode = ctx.keyLoopNode
+  ctx.keyLoopNode = keyLoop ? item : null
+  try { genIsolated(ctx, () => genCode(item, 'd', bodyLines, ctx)) } finally { ctx.plainReuse = outerReuse; ctx.fnBytes = outerBytes; ctx.keyLoopNode = outerNode }
+  if (ctx.deferredChecks) for (const dc of ctx.deferredChecks) bodyLines.push(dc)
+  ctx.deferredChecks = outerDeferred
+  if (bodyLines.length === 0 || bodyLines.some((l) => /\b_validate\b/.test(l))) return null
+  const fnName = '_it' + (ctx.itemFns = (ctx.itemFns || 0) + 1)
+  hoist(ctx, `function ${fnName}(d){${bodyLines.join('\n  ')}\n  return true}`)
+  return fnName
+}
 function countInline (lines, from, ctx) {
   let n = 0
   for (let i = from; i < lines.length; i++) n += lines[i].length
@@ -2005,6 +2092,75 @@ function sameInstanceEdges(root, node) {
   if (typeof node.$ref === 'string') { const t = localPointerTarget(root, node.$ref); if (t) out.push(t) }
   return out
 }
+// A definition that reaches a `$ref` to itself without moving to another value
+// and through no other reference (`X: { allOf: [{ $ref: X }, ...] }`, as
+// SchemaStore's cloudify has) re-enters itself on the same value. The
+// interpreted engine evaluates X once more there and answers the next
+// re-entry with true, its fixed point: X comes to f(f(true)), where f is X
+// with the reference as its argument. Reached through allOf and anyOf alone,
+// f is monotone, a conjunction with a disjunction, and then f(f(true)) is
+// f(true), so the `$ref` can be taken as true. The copy given to the
+// generators drops it, and the same-instance gate below lets the schema
+// through. Through oneOf, not, if, then or else the two differ, and those are
+// left as they are, as is a cycle through two or more references or a
+// definition some `$ref` points inside of: they still decline.
+const MONOTONE_LISTS = ['allOf', 'anyOf']
+const _selfLoopCache = new WeakMap()
+function breakSelfLoops(root) {
+  if (root === null || typeof root !== 'object') return root
+  const hit = _selfLoopCache.get(root)
+  if (hit !== undefined) return hit
+  let out = root
+  const key = root.$defs && typeof root.$defs === 'object' ? '$defs' : root.definitions && typeof root.definitions === 'object' ? 'definitions' : null
+  // The document's text is read only once a self-reference is found: almost
+  // no schema has one, and serializing every schema with definitions on every
+  // compile cost a large one a third of a millisecond for nothing.
+  let text = null
+  const doc = () => (text === null ? (text = JSON.stringify(root)) : text)
+  if (key !== null) {
+    const defs = root[key]
+    let copies = null
+    for (const name of Object.keys(defs)) {
+      const def = defs[name]
+      if (def === null || typeof def !== 'object' || Array.isArray(def)) continue
+      // Nodes of X reached on the same value without a reference, and those
+      // among them whose `$ref` names X.
+      const back = new Set()
+      const seen = new Set()
+      const walk = (n) => {
+        if (n === null || typeof n !== 'object' || seen.has(n)) return
+        seen.add(n)
+        if (typeof n.$ref === 'string' && localPointerTarget(root, n.$ref) === def) back.add(n)
+        for (const k of MONOTONE_LISTS) if (Array.isArray(n[k])) for (const x of n[k]) walk(x)
+      }
+      walk(def)
+      if (back.size === 0) continue
+      if (doc().includes('"unevaluated')) { copies = null; break }
+      // A reference into X's inside could enter one of those nodes some other way.
+      const enc = name.replace(/~/g, '~0').replace(/\//g, '~1')
+      const inside = ['#/' + key + '/' + enc + '/', '#/' + key + '/' + encodeURIComponent(enc) + '/']
+      if (inside.some((p) => doc().includes('"$ref":"' + p))) continue
+      const copy = (n, inNames) => {
+        if (n === null || typeof n !== 'object') return n
+        if (Array.isArray(n)) return n.map((x) => copy(x, false))
+        const o = {}
+        for (const k of Object.keys(n)) {
+          if (k === '$ref' && back.has(n)) continue
+          const v = !inNames && SKIP_VALUE_KEYS.has(k) ? n[k] : copy(n[k], !inNames && NAME_MAPS.has(k))
+          if (k === '__proto__') Object.defineProperty(o, k, { value: v, writable: true, enumerable: true, configurable: true })
+          else o[k] = v
+        }
+        return o
+      }
+      if (copies === null) copies = { ...defs }
+      copies[name] = copy(def)
+    }
+    if (copies !== null) out = { ...root, [key]: copies }
+  }
+  _selfLoopCache.set(root, out)
+  return out
+}
+
 const _sameInstanceCycleCache = new WeakMap()
 function hasSameInstanceRefCycle(root) {
   if (root === null || typeof root !== 'object') return false
@@ -2346,6 +2502,13 @@ function normalizeRefs(root, schemaMap) {
   return out
 }
 const SKIP_VALUE_KEYS = new Set(['enum', 'const', 'default', 'examples'])
+// The keywords whose value is a map from names to schemas. Inside one, a key
+// is a name, so `default` or `examples` there is a property with a schema,
+// not a value: the walks below skip SKIP_VALUE_KEYS only in a schema node.
+// OpenAPI 3.1's own schema has a property named `examples` whose schema is a
+// `$ref`, and the dynamic-scope copy kept it unrenamed, so the whole schema
+// fell to the interpreter.
+const NAME_MAPS = new Set(['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas'])
 // 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
@@ -2431,6 +2594,9 @@ function expandDynamicScopes(root, schemaMap) {
   }
   const copies = new Map() // node (or a boolean sentinel) -> Map(signature -> entry)
   const order = []
+  // Values kept as they are (an enum's list, a default): not copies, so the
+  // naming pass below does not walk them.
+  const keptRaw = new WeakSet()
   let fail = false
   // The entry for a node in a scope: its copy, made on the first ask, and
   // later its name. A `$ref` slot holds the entry until names are given.
@@ -2473,7 +2639,10 @@ function expandDynamicScopes(root, schemaMap) {
         continue
       }
       if (isSchema && DYN_DROP.has(k) && !(k === '$id' && node === root)) continue
-      setOwn(out, k, SKIP_VALUE_KEYS.has(k) ? v : copyValue(v, base, chain))
+      if (isSchema && SKIP_VALUE_KEYS.has(k)) {
+        if (v !== null && typeof v === 'object') keptRaw.add(v)
+        setOwn(out, k, v)
+      } else setOwn(out, k, copyValue(v, base, chain))
     }
     return e
   }
@@ -2508,7 +2677,7 @@ function expandDynamicScopes(root, schemaMap) {
         o.$ref = v.name === '#' ? '#' : '#/' + defsKey + '/' + v.name
         continue
       }
-      if (!SKIP_VALUE_KEYS.has(k)) fix(v)
+      if (!(v !== null && typeof v === 'object' && keptRaw.has(v))) fix(v)
     }
   }
   fix(rootCopy)
@@ -2542,10 +2711,10 @@ function normalizeRefsWalk(root, schemaMap) {
   const visited = new Set()
   let fail = false
   let dynamic = false
-  const visit = (node) => {
+  const visit = (node, inNames) => {
     if (fail || node === null || typeof node !== 'object' || visited.has(node)) return
     visited.add(node)
-    if (Array.isArray(node)) { for (const n of node) visit(n); return }
+    if (Array.isArray(node)) { for (const n of node) visit(n, false); return }
     if (node !== root && typeof node.$schema === 'string' && rootDialect !== null && node.$schema.replace(/#$/, '') !== rootDialect) { fail = true; return }
     // A dynamic reference reached through another document is unrolled by
     // scope the same way one in the root is (expandDynamicScopes, below).
@@ -2562,13 +2731,13 @@ function normalizeRefsWalk(root, schemaMap) {
         // The root, however it is spelled, is `#`: a copy of it under its own
         // definitions would contain itself.
         if (t === root) { /* named '#' below */ }
-        else if (typeof t === 'object' && !names.has(t)) { names.set(t, null); visit(t) }
+        else if (typeof t === 'object' && !names.has(t)) { names.set(t, null); visit(t, false) }
         if (typeof t === 'boolean' && !names.has(t)) names.set(t, null)
       }
     }
-    for (const k of Object.keys(node)) if (!SKIP_VALUE_KEYS.has(k)) visit(node[k])
+    for (const k of Object.keys(node)) if (inNames || !SKIP_VALUE_KEYS.has(k)) visit(node[k], !inNames && NAME_MAPS.has(k))
   }
-  visit(root)
+  visit(root, false)
   if (fail) return null
   if (dynamic) return expandDynamicScopes(root, schemaMap)
   if (refTarget.size === 0) return root
@@ -2582,13 +2751,13 @@ function normalizeRefsWalk(root, schemaMap) {
   }
   // The copy: references renamed, nested `$id`s dropped.
   const memo = new Map()
-  const walk = (node) => {
+  const walk = (node, inNames) => {
     if (node === null || typeof node !== 'object') return node
     if (memo.has(node)) return memo.get(node)
     if (Array.isArray(node)) {
       const out = []
       memo.set(node, out)
-      for (const x of node) out.push(walk(x))
+      for (const x of node) out.push(walk(x, false))
       return out
     }
     const out = {}
@@ -2600,13 +2769,13 @@ function normalizeRefsWalk(root, schemaMap) {
         out.$ref = t === root ? '#' : '#/' + defsKey + '/' + names.get(t)
         continue
       }
-      setOwn(out, k, SKIP_VALUE_KEYS.has(k) ? node[k] : walk(node[k]))
+      setOwn(out, k, !inNames && SKIP_VALUE_KEYS.has(k) ? node[k] : walk(node[k], !inNames && NAME_MAPS.has(k)))
     }
     return out
   }
-  const out = walk(root)
+  const out = walk(root, false)
   const defs = { ...(out[defsKey] && typeof out[defsKey] === 'object' ? out[defsKey] : {}) }
-  for (const [t, name] of names) defs[name] = typeof t === 'boolean' ? t : walk(t)
+  for (const [t, name] of names) defs[name] = typeof t === 'boolean' ? t : walk(t, false)
   out[defsKey] = defs
   return out
 }
@@ -2669,7 +2838,14 @@ function sourceSize (lines, ctx) {
 
 function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
   const inputSchema = schema
+  // The verdict alone takes a self-reference on the same value as true (see
+  // breakSelfLoops): the interpreted engine reports the errors of the second
+  // visit as well, so the error and combined generators keep declining such a
+  // schema and its errors come from that engine.
   schema = prepareForCodegen(schema, schemaMap)
+  // Only a schema with definitions can hold a self-reference; the others do
+  // not pay for compiling the function on their first schema.
+  if (schema !== null && typeof schema === 'object' && (schema.$defs || schema.definitions)) schema = breakSelfLoops(schema)
   if (typeof schema === 'boolean') return schema ? () => true : () => false
   if (typeof schema !== 'object' || schema === null) return null
   // removeAdditional: a verdict function that deletes the keys the remover
@@ -2807,13 +2983,21 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
   // validateJSON or get extended, and rewriting and compiling the source twice
   // more on every schema was about a third of what a first call cost.
   let body, hybridThunk, tailThunk, resultThunk
+  // The live verdict of a guarded schema declares its functions once, beside
+  // the preamble, and returns the entry: written in the body they were made
+  // again on every call, three closures per document (jsonld's recursive root
+  // spent a third of its 46 ns on them). The source the emitters read, `body`
+  // and the forms below, is unchanged.
+  let liveTail = null, liveDecl = null
   if (ctx.usesRecursion) {
     // Self-recursive: a named body reached through the cycle guard, so data
     // that points back at itself settles instead of exhausting the stack.
-    const decl = emitRootGuard('_validate', 'd', 'true') +
+    const decl = (ctx.rootFwd ? `${ctx.rootFwd}_f=_validate;` : '') + emitRootGuard('_validate', 'd', 'true') +
       `function _validate_b(d){\n  ${checkStr}\n  return true\n  }\n  `
     const run = emitGuardedRun('return _validate(d)', '', defSets)
     body = `${decl}function _run(d){\n  ${run}\n  }\n  return _run(d)`
+    liveDecl = `${decl}function _run(d){\n  ${run}\n  }\n  `
+    liveTail = `${liveDecl}return _run`
     // Hybrid: keep the boolean answer, wrap only the outer call
     hybridThunk = () => `${decl}function _run(d){\n  ${run}\n  }\n  return _run(d)?R:E(d)`
     resultThunk = () => `${decl}function _run(d){\n  ${run}\n  }\n  return _run(d)?${RESULT_TRUE}:${RESULT_FALSE}`
@@ -2823,6 +3007,8 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
     // re-entered with the same value; the guarded functions need their state.
     const run = emitGuardedRun(`return _body(d)`, '', defSets)
     body = `function _body(d){\n  ${checkStr}\n  return true\n  }\n  function _run(d){\n  ${run}\n  }\n  return _run(d)`
+    liveDecl = `function _body(d){\n  ${checkStr}\n  return true\n  }\n  function _run(d){\n  ${run}\n  }\n  `
+    liveTail = `${liveDecl}return _run`
     hybridThunk = () => `function _body(d){\n  ${checkStr}\n  return true\n  }\n  function _run(d){\n  ${run}\n  }\n  return _run(d)?R:E(d)`
     resultThunk = () => `function _body(d){\n  ${checkStr}\n  return true\n  }\n  function _run(d){\n  ${run}\n  }\n  return _run(d)?${RESULT_TRUE}:${RESULT_FALSE}`
     tailThunk = () => `function _body(d){\n  ${checkStr}\n  return true\n  }\n  function _run(d){\n  ${run}\n  }\n  return _run(d)&&__ataTail(d)`
@@ -2841,17 +3027,21 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
   const guardStr = needsGuard ? emitGuardState() : ''
   const preambleStr = guardStr +
     (ctx.preamble && ctx.preamble.length ? ctx.preamble.join('\n  ') + '\n  ' : '')
+  // The tag goes in front of what is compiled here, never into the sources
+  // the emitters read (_preambleSource, _source).
+  const tag = seqTag()
 
   try {
     let boolFn
-    if (closureNames.length > 0) {
-      const factory = compileFunction(...closureNames, `${preambleStr}return function(d){${body}}`)
+    if (liveTail !== null) {
+      const factory = compileFunction(...closureNames, `${tag}${preambleStr}${liveTail}`)
+      boolFn = factory(...closureValues)
+    } else if (closureNames.length > 0) {
+      const factory = compileFunction(...closureNames, `${tag}${preambleStr}return function(d){${body}}`)
       boolFn = factory(...closureValues)
-    } else if (preambleStr) {
-      const factory = compileFunction(`${preambleStr}return function(d){${body}}`)
-      boolFn = factory()
     } else {
-      boolFn = compileFunction('d', body)
+      const factory = compileFunction(`${tag}${preambleStr}return function(d){${body}}`)
+      boolFn = factory()
     }
 
     // Light by default: the pieces the tiering and standalone paths need
@@ -2871,7 +3061,7 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
       attachLazyHeavy(boolFn, inputSchema, schemaMap, userFormats, opts, !!ctx.usesSafeRe)
       return boolFn
     }
-    attachHeavy(boolFn, { ctx, closureNames, closureValues, preambleStr, guardStr, hybridBody, resultThunk, tailThunk, body })
+    attachHeavy(boolFn, { ctx, closureNames, closureValues, preambleStr, guardStr, hybridBody, resultThunk, tailThunk, body, liveDecl })
     return boolFn
   } catch {
     return null
@@ -2893,7 +3083,13 @@ function attachLazyHeavy (boolFn, schema, schemaMap, userFormats, opts, usesSafe
 }
 // The factories and the source, as the full compile attaches them.
 function attachHeavy (boolFn, P) {
-  const { ctx, closureNames, closureValues, preambleStr, guardStr, hybridBody, resultThunk, tailThunk, body } = P
+  const { ctx, closureNames, closureValues, preambleStr, guardStr, hybridBody, resultThunk, tailThunk, body, liveDecl } = P
+  // These factories are compiled later than the verdict, so they take a tag
+  // of their own (seqTag).
+  const tag = seqTag()
+  // A guarded schema's functions are declared once in each factory, as in the
+  // live verdict (see compileToJSCodegen), and each form only calls `_run`.
+  const live = (ret, thunk) => (liveDecl ? `${tag}${preambleStr}${liveDecl}return function(d){${ret}}` : `${tag}${preambleStr}return function(d){${thunk()}}`)
     // The hybrid: same body, return R instead of true, return E(d) instead of
   // false. Compiled on first request; null when that compile is refused, and
   // the caller then assembles from the error functions instead.
@@ -2901,7 +3097,7 @@ function attachHeavy (boolFn, P) {
   boolFn._hybridFactory = (R, E) => {
     if (hybridFactory === undefined) {
       try {
-        hybridFactory = compileFunction(...closureNames, 'R', 'E', `${preambleStr}return function(d){${hybridBody()}}`)
+        hybridFactory = compileFunction(...closureNames, 'R', 'E', live('return _run(d)?R:E(d)', hybridBody))
       } catch {
         hybridFactory = null
       }
@@ -2920,7 +3116,7 @@ function attachHeavy (boolFn, P) {
   boolFn._resultFactory = (LR, B, W, EE) => {
     if (resultFactory === undefined) {
       try {
-        resultFactory = compileFunction(...closureNames, '__ataLR', '__ataB', '__ataW', '__ataEE', `${preambleStr}return function(d){${resultThunk()}}`)
+        resultFactory = compileFunction(...closureNames, '__ataLR', '__ataB', '__ataW', '__ataEE', live(`return _run(d)?${RESULT_TRUE}:${RESULT_FALSE}`, resultThunk))
       } catch {
         resultFactory = null
       }
@@ -2940,7 +3136,7 @@ function attachHeavy (boolFn, P) {
   boolFn._withTail = (tail) => {
     if (tailFactory === undefined) {
       try {
-        tailFactory = compileFunction(...closureNames, '__ataTail', `${preambleStr}return function(d){${tailThunk()}}`)
+        tailFactory = compileFunction(...closureNames, '__ataTail', live('return _run(d)&&__ataTail(d)', tailThunk))
       } catch {
         tailFactory = null
       }
@@ -3439,7 +3635,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
       // object: its type check fails on undefined. A name on Object.prototype
       // is never absent that way, and it is checked explicitly.
       if (!hasTypeCheck || PROTO_NAMES.has(key)) {
-        reqChecks.push(`!${ownKeyExpr(ctx, v, key)}`)
+        reqChecks.push(`${v}[${JSON.stringify(key)}]===undefined||!${ownGuard(ctx, v, key)}`)
       } else {
         typed.push(key)
       }
@@ -3460,7 +3656,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
       lines.push(`if(!${pk || protoIs(ctx, v)}&&!_hall(${v},${JSON.stringify(typed)}))return false`)
     }
   } else if (schema.required && schema.required.length > 0) {
-    const checks = schema.required.map(key => `!${ownKeyExpr(ctx, v, key)}`)
+    const checks = schema.required.map(key => `${v}[${JSON.stringify(key)}]===undefined||!${ownGuard(ctx, v, key)}`)
     if (isObj) {
       lines.push(`if(${checks.join('||')})return false`)
     } else {
@@ -3550,7 +3746,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
 
   if (schema.pattern) {
     // Try inline charCode compilation for simple patterns (avoids RegExp engine)
-    const inlineCheck = compilePatternInline(schema.pattern, v)
+    const inlineCheck = classRunCheck(ctx, schema.pattern, v) || compilePatternInline(schema.pattern, v)
     if (inlineCheck) {
       lines.push(isStr ? `if(!(${inlineCheck}))return false` : `if(typeof ${v}==='string'&&!(${inlineCheck}))return false`)
     } else {
@@ -3661,13 +3857,32 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
 
   // properties — use hoisted vars for required props, hoist optional to locals too
   if (schema.properties) {
+    // Without a known object type, one test that the value is an object
+    // covers every property below, instead of one test per property: a
+    // definition with many optional properties stays small enough for V8 to
+    // optimize (tslint's rules, 200 of them, did not).
+    // Not an array: `properties` applies to objects only, and an array's own
+    // `length` was checked against a property of that name, rejecting a list
+    // that every other engine accepts. Only `length` and index names can be an
+    // array's own key (an inherited one fails the own-key test), so the array
+    // test is written only for those: on every other node it cost a reject
+    // path 18% in its first calls (github-issue-forms).
+    const arrayOwnable = Object.keys(schema.properties).some((k) => k === 'length' || /^(?:0|[1-9][0-9]*)$/.test(k))
+    if (!isObj) lines.push(`if(typeof ${v}==='object'&&${v}!==null${arrayOwnable ? `&&!Array.isArray(${v})` : ''}){`)
+    // The key-loop form (see emitItemFn): the optional properties are checked
+    // from the object's own keys in one loop instead of one read each.
+    const keyLoop = isObj && ctx.keyLoopNode === schema
+    const keyCases = keyLoop ? [] : null
     for (const [key, prop] of Object.entries(schema.properties)) {
+      if (keyLoop && !requiredSet.has(key)) { keyCases.push([key, prop]); continue }
       const from = lines.length
       // A large subschema as a function of its own (emitPropFn); the call
       // takes the place of the inline code in each of the three shapes below.
       const fn = propFnCandidate(prop, ctx) ? emitPropFn(prop, ctx) : null
       if (requiredSet.has(key) && isObj) {
-        // Required + type:object — hoist to local to reduce repeated property lookups
+        // Required + type:object — hoist to local to reduce repeated property lookups.
+        // A key holding undefined is missing, as in the default validator: a
+        // typed key's check fails on undefined, the others are tested above.
         const access = hoisted[key] || `${v}[${JSON.stringify(key)}]`
         const combined = fn ? null : tryGenCombined(prop, access, ctx)
         if (fn) {
@@ -3683,7 +3898,21 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
         } else {
           genCode(prop, access, lines, ctx)
         }
-      } else if (isObj) {
+      } else if (!isObj) {
+        // A value not known to be an object (tested once above): the key test
+        // first, as before, then the value, read once. An absent key costs
+        // what it did; a key holding undefined is skipped. A required key is
+        // there on any object that got this far, so its value is read first
+        // and only then asked whether it is the object's own: one test fewer,
+        // and the read an absent key would make expensive does not happen.
+        const oi = ctx.varCounter++
+        const local = `_o${oi}`
+        if (requiredSet.has(key)) lines.push(`{const ${local}=${v}[${JSON.stringify(key)}];if(${local}!==undefined&&${ownGuard(ctx, v, key)}){`)
+        else lines.push(`if(${ownKeyExpr(ctx, v, key)}){const ${local}=${v}[${JSON.stringify(key)}];if(${local}!==undefined){`)
+        if (fn) lines.push(`if(!${fn}(${local}))return false`)
+        else genCode(prop, local, lines, ctx)
+        lines.push(`}}`)
+      } else {
         // Optional — hoist to local, check undefined
         const oi = ctx.varCounter++
         const local = `_o${oi}`
@@ -3697,14 +3926,28 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
           genCode(prop, local, lines, ctx)
         }
         lines.push(`}}`)
-      } else {
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}){`)
-        if (fn) lines.push(`if(!${fn}(${v}[${JSON.stringify(key)}]))return false`)
-        else genCode(prop, `${v}[${JSON.stringify(key)}]`, lines, ctx)
-        lines.push(`}`)
       }
       countInline(lines, from, ctx)
     }
+    if (keyCases !== null && keyCases.length > 0) {
+      const kk = `_kk${ctx.varCounter++}`
+      const kv = `_kv${ctx.varCounter++}`
+      // The switch is one line: callers join lines with `;`, and a `;`
+      // before a `case` is a syntax error (the error generator's guard did
+      // that, and the rich error program silently fell back to the plain one).
+      let cases = ''
+      for (const [key, prop] of keyCases) {
+        const caseLines = []
+        const fn = propFnCandidate(prop, ctx) ? emitPropFn(prop, ctx) : null
+        const combined = fn ? null : tryGenCombined(prop, kv, ctx)
+        if (fn) caseLines.push(`if(!${fn}(${kv}))return false`)
+        else if (combined) caseLines.push(combined)
+        else genCode(prop, kv, caseLines, ctx)
+        cases += `case ${JSON.stringify(key)}:{${caseLines.join(';')};break}`
+      }
+      lines.push(`{${ownHead(ctx, v, kk, 'const')}{const ${kv}=${v}[${kk}];if(${kv}!==undefined){switch(${kk}){${cases}}}}}`)
+    }
+    if (!isObj) lines.push(`}`)
   }
 
   // items — pass known type info to children
@@ -3714,11 +3957,26 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
     ctx.varCounter++
     // items applies after the prefixItems positions (Draft 2020-12).
     const start = Array.isArray(schema.prefixItems) ? schema.prefixItems.length : 0
-    lines.push(isArr
-      ? `for(let ${idx}=${start};${idx}<${v}.length;${idx}++){const ${elem}=${v}[${idx}]`
-      : `if(Array.isArray(${v})){for(let ${idx}=${start};${idx}<${v}.length;${idx}++){const ${elem}=${v}[${idx}]`)
-    genCode(schema.items, elem, lines, ctx)
-    lines.push(isArr ? `}` : `}}`)
+    const fk = keyLoopEligible(schema.items) ? emitItemFn(schema.items, ctx, true) : null
+    if (fk !== null) {
+      // Records with many optional properties: when three of them (first,
+      // middle, last) list their keys alike, they likely share one shape and
+      // reading each declared property, written in the loop as always, is
+      // cheapest; when they do not, each record walks its own keys instead
+      // (fk), which costs the same whatever their shapes. Decided per call,
+      // from three items.
+      hoistOnce(ctx, 'sameKeysHelper', SAME_KEYS_HELPER)
+      const n = `_n${ctx.varCounter++}`
+      lines.push(`${isArr ? '' : `if(Array.isArray(${v}))`}{const ${n}=${v}.length;if(${n}-${start}>2&&(!_sameKeys(${v}[${start}],${v}[(${n}+${start})>>1])||!_sameKeys(${v}[${start}],${v}[${n}-1]))){for(let ${idx}=${start};${idx}<${n};${idx}++)if(!${fk}(${v}[${idx}]))return false}else{for(let ${idx}=${start};${idx}<${n};${idx}++){const ${elem}=${v}[${idx}]`)
+      genCode(schema.items, elem, lines, ctx)
+      lines.push(`}}}`)
+    } else {
+      lines.push(isArr
+        ? `for(let ${idx}=${start};${idx}<${v}.length;${idx}++){const ${elem}=${v}[${idx}]`
+        : `if(Array.isArray(${v})){for(let ${idx}=${start};${idx}<${v}.length;${idx}++){const ${elem}=${v}[${idx}]`)
+      genCode(schema.items, elem, lines, ctx)
+      lines.push(isArr ? `}` : `}}`)
+    }
   }
 
   // prefixItems
@@ -3753,7 +4011,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
 
   // oneOf — branch fns hoisted to factory scope when safe (no recursion/ref).
   // Falls back to inline closures if any branch touches recursive validation.
-  if (schema.oneOf) genOneOfNode(schema, v, applicatorLines, ctx, knownType)
+  if (schema.oneOf) genOneOfNode(schema, v, applicatorLines, ctx, effectiveType)
 
   // not
   if (schema.not !== undefined) genNotNode(schema, v, lines, ctx, knownType)
@@ -3922,7 +4180,42 @@ function genContainsNode(schema, v, lines, ctx, knownType, isArr) {
   }
 }
 
+// A branch of anyOf or oneOf that cannot be a function in the preamble (it
+// calls `_validate`, the recursive entry, which is not in scope there) was a
+// closure in an array built on every call. Written in place instead, as a
+// labelled block whose `return false` becomes the break out of it: jsonld's
+// root anyOf, one branch of which recurses, took 61 ns a document against 30
+// for the default validator. Only a body with no function of its own, whose
+// returns are all `return false`; the parameter becomes a local of the block,
+// and `\b` leaves longer names that start the same alone.
+function inlineBranchBody (body, param, label, local) {
+  if (/\bfunction\b|=>|\bthis\b|\barguments\b/.test(body)) return null
+  let core
+  if (body === 'return true') core = ''
+  else if (body.endsWith(';return true')) core = body.slice(0, -';return true'.length)
+  else return null
+  if (/\breturn\b(?! false\b)/.test(core)) return null
+  const re = new RegExp('\\b' + param + '\\b', 'g')
+  return core.replace(/\breturn false\b/g, 'break ' + label).replace(re, local)
+}
+
+// A single-branch anyOf or oneOf holds exactly when its branch does, so the
+// branch is written in place. When the branch is only a $ref that an allOf
+// beside it also applies, it is already checked and nothing is written:
+// devinit's items are `{ allOf: [{ $ref: R }], anyOf: [{ $ref: R }] }`, and
+// each run object was checked twice. The verdict only; errors keep the
+// keyword's own shape.
+const refOnly = (b) => b !== null && typeof b === 'object' && typeof b.$ref === 'string' && Object.keys(b).every((k) => k === '$ref' || REF_NEUTRAL_SIBLINGS.has(k))
+function singleBranch(schema, branches, v, lines, ctx, knownType) {
+  if (branches.length !== 1) return false
+  const b = branches[0]
+  if (refOnly(b) && Array.isArray(schema.allOf) && schema.allOf.some((x) => refOnly(x) && x.$ref === b.$ref)) return true
+  genCode(b, v, lines, ctx, knownType)
+  return true
+}
+
 function genAnyOfNode(schema, v, lines, ctx, knownType) {
+  if (singleBranch(schema, schema.anyOf, v, lines, ctx, knownType)) return
   const fi = ctx.varCounter++
   const branchBodies = []
   const reused = []
@@ -3958,6 +4251,13 @@ function genAnyOfNode(schema, v, lines, ctx, knownType) {
     const checks = names.map(n => `${n}(${v})`).join('||')
     lines.push(`if(!(${checks}))return false`)
   } else {
+    const inl = branchBodies.map((body, i) => inlineBranchBody(body, '_av', `_al${fi}_${i}`, `_ai${fi}_${i}`))
+    if (inl.every((x) => x !== null)) {
+      const m = `_am${fi}`
+      const blocks = inl.map((core, i) => `_al${fi}_${i}:{const _ai${fi}_${i}=${v};${core};${m}=true}`)
+      lines.push(`{let ${m}=false;${blocks.map((b, i) => (i === 0 ? b : `if(!${m}){${b}}`)).join('')}if(!${m})return false}`)
+      return
+    }
     const fns = branchBodies.map(body => `function(_av){${body}}`)
     lines.push(`{const _af${fi}=[${fns.join(',')}];let _am${fi}=false;for(let _ai=0;_ai<_af${fi}.length;_ai++){if(_af${fi}[_ai](${v})){_am${fi}=true;break}}if(!_am${fi})return false}`)
   }
@@ -4009,6 +4309,7 @@ function keyedBranches (branches) {
 }
 
 function genOneOfNode(schema, v, lines, ctx, knownType) {
+  if (singleBranch(schema, schema.oneOf, v, lines, ctx, knownType)) return
   const fi = ctx.varCounter++
   const branchBodies = []
   const reused = []
@@ -4020,19 +4321,24 @@ function genOneOfNode(schema, v, lines, ctx, knownType) {
   // 86919 branch functions and 197 MB of source, and took seconds to build.
   // A hoisted branch takes its input as a parameter and reads only
   // module-level names, so the same schema object gives the same function.
-  if (canHoist && !ctx.hoistedBranch) ctx.hoistedBranch = new Map()
+  // A branch reached with an object already checked is written for one, a
+  // different function, so it is reused only for the same known type.
+  const kt = knownType === 'object' ? 'object' : undefined
+  const mapName = kt ? 'hoistedBranchObj' : 'hoistedBranch'
+  if (canHoist && !ctx[mapName]) ctx[mapName] = new Map()
+  const branchMap = canHoist ? ctx[mapName] : null
   for (let i = 0; i < schema.oneOf.length; i++) {
     const sub = schema.oneOf[i]
     const key = canHoist ? branchKey(sub, ctx) : undefined
-    const known = key !== undefined ? ctx.hoistedBranch.get(key) : undefined
+    const known = key !== undefined ? branchMap.get(key) : undefined
     if (known !== undefined) {
       reused[i] = known.name
       branchBodies.push(known.body)
       continue
     }
     const subLines = []
-    if (canHoist) genIsolated(ctx, () => genCode(sub, '_ov', subLines, ctx))
-    else genCode(sub, '_ov', subLines, ctx)
+    if (canHoist) genIsolated(ctx, () => genCode(sub, '_ov', subLines, ctx, kt))
+    else genCode(sub, '_ov', subLines, ctx, kt)
     const body = subLines.length === 0 ? 'return true' : `${subLines.join(';')};return true`
     // _validate is the recursive entry — hoisting branches above it breaks scope.
     if (/\b_validate\b/.test(body)) canHoist = false
@@ -4044,7 +4350,7 @@ function genOneOfNode(schema, v, lines, ctx, knownType) {
       const name = `_of${fi}_b${i}`
       hoist(ctx, `function ${name}(_ov){${body}}`)
       const key = branchKey(schema.oneOf[i], ctx)
-      if (key !== undefined) ctx.hoistedBranch.set(key, { name, body })
+      if (key !== undefined) branchMap.set(key, { name, body })
       return name
     })
     const calls = names.map(n => `if(${n}(${v})){_oc${fi}++;if(_oc${fi}>1)return false}`).join(';')
@@ -4061,12 +4367,77 @@ function genOneOfNode(schema, v, lines, ctx, knownType) {
     }
     lines.push(`{let _oc${fi}=0;${calls};if(_oc${fi}!==1)return false}`)
   } else {
+    const inl = branchBodies.map((body, i) => inlineBranchBody(body, '_ov', `_ol${fi}_${i}`, `_oj${fi}_${i}`))
+    if (inl.every((x) => x !== null)) {
+      const c = `_oc${fi}`
+      const blocks = inl.map((core, i) => `_ol${fi}_${i}:{const _oj${fi}_${i}=${v};${core};if(++${c}>1)return false}`)
+      lines.push(`{let ${c}=0;${blocks.join('')}if(${c}!==1)return false}`)
+      return
+    }
     const fns = branchBodies.map(body => `function(_ov){${body}}`)
     lines.push(`{const _of${fi}=[${fns.join(',')}];let _oc${fi}=0;for(let _oi=0;_oi<_of${fi}.length;_oi++){if(_of${fi}[_oi](${v}))_oc${fi}++;if(_oc${fi}>1)return false}if(_oc${fi}!==1)return false}`)
   }
 }
 
+// A subschema checked on the same value (`not`, `if`, `then`, `else`) as a
+// named function in the preamble, so the check allocates nothing: written in
+// the body, each was a closure created on every call, and SchemaStore's
+// cloudify, about 3000 if/then pairs, spent most of its time making them.
+// Generated over its own parameter, like a hoisted oneOf branch. Null where
+// it cannot be hoisted, and the caller writes the closure as before.
+// The function also takes whether the value is an ordinary object (see
+// withPlain), which the caller has usually worked out already: each of
+// minecraft-predicate's 25 if/then pairs read the object's prototype again.
+function hoistedCheck (ctx, sub, param, prefix) {
+  if (!ctx.preamble) return null
+  const bodyLines = []
+  const outerDeferred = ctx.deferredChecks
+  ctx.deferredChecks = null
+  const outerReuse = ctx.plainReuse
+  const flag = param + 'pk'
+  ctx.plainReuse = param
+  try {
+    genIsolated(ctx, () => {
+      ctx.plainOf = new Map([[param, flag]])
+      genCode(sub, param, bodyLines, ctx)
+    })
+  } finally { ctx.plainReuse = outerReuse }
+  if (ctx.deferredChecks) for (const dc of ctx.deferredChecks) bodyLines.push(dc)
+  ctx.deferredChecks = outerDeferred
+  const body = bodyLines.length === 0 ? 'return true' : `${bodyLines.join(';')};return true`
+  // _validate is the recursive entry, not in scope above it.
+  if (/\b_validate\b/.test(body)) return null
+  const name = prefix + ctx.varCounter++
+  // A body that never asks takes no flag, so the caller does not work it out.
+  if (new RegExp('\\b' + flag + '\\b').test(body)) {
+    hoist(ctx, `function ${name}(${param},${flag}){${body}}`)
+  } else {
+    if (!ctx.flaglessChecks) ctx.flaglessChecks = new Set()
+    ctx.flaglessChecks.add(name)
+    hoist(ctx, `function ${name}(${param}){${body}}`)
+  }
+  return name
+}
+// A call to a function from hoistedCheck, with the flag argument only where
+// the function takes one.
+function callHoisted (ctx, name, v, pk) {
+  return ctx.flaglessChecks && ctx.flaglessChecks.has(name) ? `${name}(${v})` : `${name}(${v},${pk})`
+}
+// The second argument to a function from hoistedCheck: the caller's flag for
+// the value when it has one, else the test itself. Not inside the boolean
+// code the error and combined generators nest in their own functions, where a
+// flag recorded for the value may belong to a scope the call is not in.
+function plainArg (ctx, v) {
+  const pk = ctx.nestedBoolean ? undefined : plainFlag(ctx, v)
+  return pk || `(typeof ${v}==='object'&&${v}!==null&&${protoIs(ctx, v)})`
+}
+
 function genNotNode(schema, v, lines, ctx, knownType) {
+  const hoisted = hoistedCheck(ctx, schema.not, '_nv', '_nh')
+  if (hoisted !== null) {
+    lines.push(`if(${callHoisted(ctx, hoisted, v, plainArg(ctx, v))})return false`)
+    return
+  }
   const subLines = []
   genCode(schema.not, '_nv', subLines, ctx)
   if (subLines.length === 0) {
@@ -4078,6 +4449,29 @@ function genNotNode(schema, v, lines, ctx, knownType) {
 }
 
 function genIfNode(schema, v, lines, ctx, knownType) {
+  if (ctx.preamble) {
+    const ifName = hoistedCheck(ctx, schema.if, '_iv', '_ih')
+    const thenName = ifName !== null && schema.then !== undefined ? hoistedCheck(ctx, schema.then, '_tv', '_th') : null
+    const elseName = ifName !== null && schema.else !== undefined ? hoistedCheck(ctx, schema.else, '_ev', '_eh') : null
+    if (ifName !== null && (schema.then === undefined || thenName !== null) && (schema.else === undefined || elseName !== null)) {
+      if (thenName === null && elseName === null) return
+      // The flag is worked out once: from the caller when it has one, else in
+      // a local when more than one of the functions takes it.
+      const takers = [ifName, thenName, elseName].filter((n) => n !== null && !(ctx.flaglessChecks && ctx.flaglessChecks.has(n))).length
+      let pk = plainArg(ctx, v)
+      let open = '', close = ''
+      if (takers > 1 && !/^[\w$]+$/.test(pk)) {
+        const local = `_ipk${ctx.varCounter++}`
+        open = `{const ${local}=${pk};`
+        close = '}'
+        pk = local
+      }
+      const thenCheck = thenName !== null ? `if(!${callHoisted(ctx, thenName, v, pk)})return false` : ''
+      const elseCheck = elseName !== null ? `if(!${callHoisted(ctx, elseName, v, pk)})return false` : ''
+      lines.push(`${open}if(${callHoisted(ctx, ifName, v, pk)}){${thenCheck}}else{${elseCheck}}${close}`)
+      return
+    }
+  }
   const ifLines = []
   genCode(schema.if, '_iv', ifLines, ctx)
   const fi = ctx.varCounter++
@@ -4104,12 +4498,30 @@ function genIfNode(schema, v, lines, ctx, knownType) {
   lines.push(`if(_if${fi}(${v})){if(_th${fi}&&!_th${fi}(${v}))return false}else{if(_el${fi}&&!_el${fi}(${v}))return false}}`)
 }
 
+// The root as a definition function in the preamble reaches it: a function
+// declared there that calls whatever the entry stored in its slot, which the
+// entry's declarations fill in (see compileToJSCodegen). Named per compile,
+// and written with hoist, not hoistOnce, so a bundle never shares one slot
+// between two schemas. SchemaStore's jsone, whose definitions refer back to
+// the root, ran on the interpreter for want of it.
+function rootForwarder (ctx) {
+  if (!ctx.rootFwd) {
+    const name = `_root${ctx.varCounter++}`
+    ctx.rootFwd = name
+    hoist(ctx, `let ${name}_f=null;function ${name}(d){return ${name}_f(d)}`)
+  }
+  return ctx.rootFwd
+}
+
 function genRefNode(schema, v, lines, ctx, knownType, hasSiblings) {
   // Self-reference "#" — recursive call to root validator
   if (schema.$ref === '#') {
     if (ctx.nestedBoolean) throw DECLINE
     ctx.usesRecursion = true
-    lines.push(`if(!_validate(${v}))return false`)
+    // Inside a definition function, which sits in the preamble where the
+    // entry is not in scope, the root is reached through a forwarder the
+    // entry fills in (rootForwarder).
+    lines.push(`if(!${ctx.inDefFn ? rootForwarder(ctx) : '_validate'}(${v}))return false`)
     if (!hasSiblings) return true
   }
   // 1. Local ref
@@ -4136,14 +4548,14 @@ function genRefNode(schema, v, lines, ctx, knownType, hasSiblings) {
         ctx.deferredChecks = null
         const outerReuse = ctx.plainReuse
         ctx.plainReuse = undefined
-        try { genIsolated(ctx, () => genCode(ctx.rootDefs[defName], 'd', bodyLines, ctx)) } finally { ctx.plainReuse = outerReuse }
+        ctx.inDefFn = (ctx.inDefFn || 0) + 1
+        try { genIsolated(ctx, () => genCode(ctx.rootDefs[defName], 'd', bodyLines, ctx)) } finally { ctx.plainReuse = outerReuse; ctx.inDefFn-- }
         if (ctx.deferredChecks) for (const dc of ctx.deferredChecks) bodyLines.push(dc)
         ctx.deferredChecks = outerDeferred
         // The def is hoisted above the entry function, where the recursive
-        // entry `_validate` is not in scope; a body that calls it (a `$ref: '#'`
-        // inside the def) threw a ReferenceError at the first document that
-        // reached it. SchemaStore's jsone schema is such a case. Decline, as
-        // oneOf and anyOf do not hoist such a branch.
+        // entry `_validate` is not in scope: a `$ref: '#'` inside it goes
+        // through the forwarder (rootForwarder). Anything else naming the
+        // entry still declines, as oneOf and anyOf do not hoist such a branch.
         if (bodyLines.some((l) => /\b_validate\b/.test(l))) throw DECLINE
         // Entered through the cycle guard: see emitGuardState. In the fast
         // pass the wrapper only counts depth; the set is used by the second,
@@ -4333,8 +4745,15 @@ function genPatternPropertiesNode(schema, v, lines, ctx, knownType, isObj) {
     }
     lines.push(`}}`)
   } else {
-    // No additionalProperties: validate matching keys + propertyNames
+    // No additionalProperties: validate matching keys + propertyNames.
+    // A pattern whose subschema checks nothing (`{}`, `true`), as OpenAPI's
+    // `^x-` extensions are on nearly every object, needs no matching here:
+    // the loop read every key's value and did nothing with it. With no such
+    // check left and no propertyNames, there is no loop at all.
     handledPropertyNames = !!pn
+    const live = []
+    for (let i = 0; i < ppEntries.length; i++) if (subChecks[i] !== '') live.push(i)
+    if (!pn && live.length === 0) return handledPropertyNames
     lines.push(`${guard}{${ownHead(ctx, v, kVar, 'const')}{`)
     // propertyNames checks (merged)
     if (pn) {
@@ -4359,7 +4778,7 @@ function genPatternPropertiesNode(schema, v, lines, ctx, knownType, isObj) {
         lines.push(`if(!_es${ei}.has(${kVar}))return false`)
       }
     }
-    for (let i = 0; i < ppEntries.length; i++) {
+    for (const i of live) {
       lines.push(`if(${matchers[i].check}){const _ppv${pi}=${v}[${kVar}];${subChecks[i]}}`)
     }
     lines.push(`}}`)
@@ -4920,8 +5339,19 @@ const FORMAT_CODEGEN = {
   'json-pointer': (...a) => getFormats().jsonPointerSource(...a),
   'relative-json-pointer': (...a) => getFormats().relativeJsonPointerSource(...a),
   'uri-template': (...a) => getFormats().uriTemplateSource(...a),
-  iri: (...a) => getFormats().iriSource(...a),
-  'iri-reference': (...a) => getFormats().iriReferenceSource(...a),
+  // The URI family shares one hoisted walk (uriHelper): `_uri` is the uri
+  // check with its regex in front, `_urif(s, mode)` the other three with
+  // theirs, `_uriw(s, mode)` the walk itself.
+  iri: (v, isStr, ctx) => {
+    if (!ctx) return getFormats().iriSource(v, isStr)
+    hoistOnce(ctx, '_uriHoisted', uriHelper())
+    return isStr ? `if(!_urif(${v},3))return false` : `if(typeof ${v}==='string'&&!_urif(${v},3))return false`
+  },
+  'iri-reference': (v, isStr, ctx) => {
+    if (!ctx) return getFormats().iriReferenceSource(v, isStr)
+    hoistOnce(ctx, '_uriHoisted', uriHelper())
+    return isStr ? `if(!_urif(${v},2))return false` : `if(typeof ${v}==='string'&&!_urif(${v},2))return false`
+  },
   'idn-email': (...a) => getFormats().idnEmailSource(...a),
   regex: (v, isStr) => {
     const inner = `try{new RegExp(${v},'u')}catch(_er){return false}`
@@ -4937,9 +5367,11 @@ const FORMAT_CODEGEN = {
     hoistOnce(ctx, '_uriHoisted', uriHelper())
     return isStr ? `if(!_uri(${v}))return false` : `if(typeof ${v}==='string'&&!_uri(${v}))return false`
   },
-  'uri-reference': (v, isStr) => isStr
-    ? `{${getFormats().uriCharsSource(v, '0')}}`
-    : `if(typeof ${v}==='string'){${getFormats().uriCharsSource(v, '0')}}`,
+  'uri-reference': (v, isStr, ctx) => {
+    if (!ctx) return getFormats().uriReferenceSource(v, isStr)
+    hoistOnce(ctx, '_uriHoisted', uriHelper())
+    return isStr ? `if(!_urif(${v},0))return false` : `if(typeof ${v}==='string'&&!_urif(${v},0))return false`
+  },
   ipv4: (v, isStr, ctx) => {
     if (!ctx) return getFormats().ipv4Source(v, isStr)
     // Hoisted: a regex literal in the body would build a new RegExp per call.
@@ -4957,6 +5389,38 @@ const FORMAT_CODEGEN = {
   hostname: (...a) => getFormats().hostnameSource(...a),
 }
 
+// `^[class]+$`, `^[class]{m,n}$` and `^[class]{n}$` for a class of ASCII
+// letters, digits, `_` and `-`: a function in the preamble that reads each
+// character once and looks it up in a 128-entry table. The inline form below
+// read it again for every range it compared and built an arrow function on
+// every call; component.json's `^[0-9a-z-_]+$` cost the default validator's
+// RegExp the same. Null without a preamble, or for any other shape.
+function classRunCheck (ctx, pattern, v) {
+  if (!ctx || !ctx.preamble) return null
+  let m = pattern.match(/^\^(\[[\w\-]+\])(\+|\{(\d+)\}|\{(\d+),(\d+)\})\$$/)
+  if (!m) return null
+  const cls = m[1]
+  let min, max
+  if (m[2] === '+') { min = 1; max = Infinity }
+  else if (m[3] !== undefined) { min = max = +m[3]; if (max <= 16) return null }
+  else { min = +m[4]; max = +m[5] }
+  if (!(min <= max)) return null
+  let re
+  try { re = new RegExp('^' + cls + '$') } catch { return null }
+  if (!ctx.classRuns) ctx.classRuns = new Map()
+  const key = cls + '|' + min + '|' + max
+  let name = ctx.classRuns.get(key)
+  if (name === undefined) {
+    name = '_cr' + ctx.varCounter++
+    ctx.classRuns.set(key, name)
+    const bits = []
+    for (let c = 0; c < 128; c++) bits.push(re.test(String.fromCharCode(c)) ? 1 : 0)
+    const lenCheck = max === Infinity ? `n<${min}` : min === max ? `n!==${min}` : `n<${min}||n>${max}`
+    hoist(ctx, `const ${name}_t=new Uint8Array([${bits.join(',')}])\n  function ${name}(s){const n=s.length;if(${lenCheck})return false;for(let i=0;i<n;i++){const c=s.charCodeAt(i);if(c>127||${name}_t[c]===0)return false}return true}`)
+  }
+  return `${name}(${v})`
+}
+
 // Compile simple regex patterns to inline charCode checks — avoids RegExp engine overhead.
 // Returns null if pattern is too complex for inline compilation.
 // Handles: ^[charclass]{n}$, ^[charclass]+$, ^[charclass]*$, ^[charclass]{m,n}$
@@ -5143,6 +5607,14 @@ function unevalContributions (sub, kind, names, state, depth) {
 // 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) {
+  // ^name$ or ^(a|b)$ of plain characters is string equality (`$` without
+  // the m flag ends the input); `.*` matches every string.
+  const ex = pattern.match(/^\^(?:\(([a-zA-Z0-9_-]+(?:\|[a-zA-Z0-9_-]+)*)\)|([a-zA-Z0-9_-]+))\$$/)
+  if (ex) {
+    const alts = (ex[1] || ex[2]).split('|')
+    if (alts.length <= 8) return `(${alts.map((a) => `${keyVar}===${JSON.stringify(a)}`).join('||')})`
+  }
+  if (pattern === '.*') return 'true'
   // Match patterns like ^literal (no regex metacharacters after ^)
   const m = pattern.match(/^\^([a-zA-Z0-9_\-./]+)$/)
   if (!m) return null
@@ -5570,4 +6042,4 @@ Object.defineProperty(module.exports, '_expandDynamicScopes', { value: expandDyn
 // 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 })
 
-module.exports._internal = { ownHead, hasConstraints, assertEmitted, prepareForCodegen, sharedCodegenGate, codegenSafe, isSimplePN, hasUnresolvableRef, needsBaseTracking, _cpLen, sharedRt, DECLINE, bindRt, compileSafe, emitGuardState, withPlain, REF_NEUTRAL_SIBLINGS, resolveCrossSchemaRef, enumCondition, enumOperand, emitDeq, emitConstant, ownGuard, ownKeyExpr, multipleOfBad, compilePatternInline, useSafeEngine, reFlags, FORMAT_CODEGEN, PROTO_NAMES, setOwn, nestedGenCode, compileToJSCodegen, SKIP_VALUE_KEYS, skipString, CYCLE_DEPTH, cyclicDefNames, sharedDefNames, reFlagArg, hoistOnce, PTR_ESC_HELPER, unevalContributions, emitUq, uqSources, safeReClosure, fastPrefixCheck, replaceTopLevel, refTargetFor, genCode, addLocalAnnotations, addTopApplicatorAnnotations, protoIs, ANNOT_APPLICATORS, SIZE_SKIPS, emitRootGuard, emitGuardedRun }
+module.exports._internal = { ownHead, hasConstraints, assertEmitted, prepareForCodegen, sharedCodegenGate, codegenSafe, isSimplePN, hasUnresolvableRef, needsBaseTracking, _cpLen, sharedRt, DECLINE, bindRt, compileSafe, emitGuardState, withPlain, REF_NEUTRAL_SIBLINGS, resolveCrossSchemaRef, enumCondition, enumOperand, emitDeq, emitConstant, ownGuard, ownKeyExpr, multipleOfBad, compilePatternInline, useSafeEngine, reFlags, FORMAT_CODEGEN, PROTO_NAMES, setOwn, nestedGenCode, compileToJSCodegen, SKIP_VALUE_KEYS, skipString, CYCLE_DEPTH, cyclicDefNames, sharedDefNames, reFlagArg, hoistOnce, PTR_ESC_HELPER, unevalContributions, emitUq, uqSources, safeReClosure, fastPrefixCheck, replaceTopLevel, refTargetFor, genCode, addLocalAnnotations, addTopApplicatorAnnotations, protoIs, ANNOT_APPLICATORS, SIZE_SKIPS, emitRootGuard, emitGuardedRun, keyLoopEligible, SAME_KEYS_HELPER, seqTag }