ata-validator 1.45.0 → 1.46.1

package/lib/js-compiler.js

@@ -30,9 +30,23 @@ function uqSources () {
 // for exactly this; the error and combined generators emit `helperCode` into
 // their function source. The boolean generator's `helperCode` is only
 // scanned for regex entries and must not be used here.
+// The helpers the one-pass generator takes from lib/combined-runtime.js as
+// closure values instead of writing into each program, by the hoistOnce key
+// that would have written them.
+const SHARED_RT = {
+  _deqHoisted: ['_deq'], _peHoisted: ['_pe'],
+  _own_PN: ['_PN', '_OP', '_gp'], _own_hop: ['_hop'], _own_h: ['_h'], _own_ok: ['_ok'], _own_hall: ['_hall'],
+}
+let _rt = null
+function sharedRt () { return _rt || (_rt = require('./combined-runtime')) }
+function bindRt (ctx, names) {
+  const rt = sharedRt()
+  for (const n of names) { ctx.closureVars.push(n); ctx.closureVals.push(rt[n]) }
+}
 function hoistOnce(ctx, key, code) {
   if (ctx[key]) return
   ctx[key] = true
+  if (ctx.sharedRuntime && SHARED_RT[key] !== undefined) { bindRt(ctx, SHARED_RT[key]); return }
   // Recorded as shared: the text is a constant and the name it declares is
   // fixed, so several compiled schemas in one bundle can use one copy. The
   // rest of the preamble cannot move, because emitConstant and the generated
@@ -169,7 +183,7 @@ function enumCondition(ctx, vals, v) {
 
 
 const { codeFor } = require('./error-codes')
-const { ordinalFor } = require('./schema-order')
+const { ordinalFor, rankFor } = require('./schema-order')
 const { compileSafe, patternIsSafe } = require('./safe-regex')
 // Whether a pattern goes to the linear-time engine. A pattern the platform
 // RegExp also runs in linear time (nativeIsLinear) takes the RegExp: it answers
@@ -1037,6 +1051,11 @@ function withPlain (schema, v, lines, ctx, run) {
     return run()
   }
   if (!ctx.plainOf) ctx.plainOf = new Map()
+  // A flag an enclosing node already declared for this same value stands:
+  // the straight-line unevaluatedProperties code (inlineUnevalBlock) declares
+  // one for the object and writes every branch's verdict under it, where each
+  // branch used to read the prototype again.
+  if (ctx.plainReuse === v && ctx.plainOf.get(v) !== undefined) return run()
   const name = '_pk' + ctx.varCounter++
   const at = lines.length
   const decl = `const ${name}=typeof ${v}==='object'&&${v}!==null&&${protoIs(ctx, v)}`
@@ -2261,12 +2280,165 @@ function refsAllPlainLocal (root, text) {
 // 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()
+// `$dynamicRef` resolved at compile time, the way the interpreted engine
+// resolves it: the target depends on the dynamic scope, the resources entered
+// on the way to the reference, so the schema is unrolled into one copy per
+// (node, scope) pair and every reference in a copy becomes a plain local
+// reference to the copy its scope selects. Two scopes are the same when every
+// dynamic anchor name resolves to the same resource in both, which is what
+// the lookup reads; keyed that way, a schema whose anchors all sit at the
+// root (the 2020-12 meta-schema) gets one copy per node, not one per path.
+// Nested `$id`, `$anchor` and `$dynamicAnchor` are dropped from the copies,
+// since nothing refers by them any more. Any reference that does not resolve
+// makes the whole rewrite give up (null) and the schema goes to the
+// interpreted engine, which reports it where it is reached: an unrolled copy
+// must never leave a reference out, because a reference that is not written
+// checks nothing. 2020-12 bookending is assumed: the v1 dialect, which drops
+// it, is routed to the interpreted engine before code generation is asked.
+// Dropped from every copy: identifiers, which nothing refers by any more,
+// and definition containers, whose members are reached only through the
+// references that name them and are copied where those land. A definition
+// nothing uses would otherwise sit in the output and could cost it the
+// generated code.
+const DYN_DROP = new Set(['$id', '$anchor', '$dynamicAnchor', '$defs', 'definitions'])
+const BOOL_TRUE = { bool: true }
+const BOOL_FALSE = { bool: false }
+function expandDynamicScopes(root, schemaMap) {
+  if (root === null || typeof root !== 'object' || Array.isArray(root)) return null
+  const { indexSchemas, resolveRef, splitFragment, resolveUri } = require('./interpreter')._refInternals
+  let state
+  try { state = indexSchemas(root, schemaMap && schemaMap.size ? schemaMap : null) } catch { return null }
+  const anchorNames = []
+  for (const m of state.dynamicAnchors.values()) for (const name of m.keys()) if (!anchorNames.includes(name)) anchorNames.push(name)
+  anchorNames.sort()
+  // The scope signature: for each anchor name, the first resource in the
+  // chain that declares it.
+  const signature = (chain) => {
+    let sig = ''
+    for (const name of anchorNames) {
+      let hit = ''
+      for (let i = 0; i < chain.length; i++) { const dyn = state.dynamicAnchors.get(chain[i]); if (dyn && dyn.has(name)) { hit = chain[i]; break } }
+      sig += name + '=' + hit + ';'
+    }
+    return sig
+  }
+  const resolveDynamic = (ref, base, chain) => {
+    let { node, base: refBase } = resolveRef(ref, base, state)
+    const [, fragment] = splitFragment(resolveUri(base, ref))
+    if (fragment && !fragment.startsWith('/')) {
+      const initialDyn = state.dynamicAnchors.get(refBase)
+      const bookended = node !== undefined && initialDyn !== undefined && initialDyn.get(fragment) === node
+      if (bookended) {
+        for (let i = 0; i < chain.length; i++) {
+          const dyn = state.dynamicAnchors.get(chain[i])
+          if (dyn && dyn.has(fragment)) { node = dyn.get(fragment); refBase = chain[i]; break }
+        }
+      }
+    }
+    return { node, base: refBase }
+  }
+  const copies = new Map() // node (or a boolean sentinel) -> Map(signature -> entry)
+  const order = []
+  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.
+  const entryFor = (node, base, chain) => {
+    if (node === true || node === false) {
+      const key = node ? BOOL_TRUE : BOOL_FALSE
+      let bySig = copies.get(key)
+      if (bySig === undefined) { bySig = new Map(); copies.set(key, bySig) }
+      let e = bySig.get('')
+      if (e === undefined) { e = { copy: node, sig: '', name: null, referenced: false }; bySig.set('', e); order.push(e) }
+      return e
+    }
+    if (node === null || typeof node !== 'object') { fail = true; return { copy: node, sig: '', name: null } }
+    if (state.nodeBase.has(node) && state.nodeBase.get(node) !== base) base = state.nodeBase.get(node)
+    if (!chain.includes(base)) chain = chain.concat(base)
+    const sig = signature(chain)
+    let bySig = copies.get(node)
+    if (bySig === undefined) { bySig = new Map(); copies.set(node, bySig) }
+    const hit = bySig.get(sig)
+    if (hit !== undefined) return hit
+    const e = { copy: Array.isArray(node) ? [] : {}, sig, name: null, referenced: false }
+    bySig.set(sig, e)
+    order.push(e)
+    if (Array.isArray(node)) { for (const x of node) e.copy.push(copyValue(x, base, chain)); return e }
+    const out = e.copy
+    // Only a schema node reads `$ref` as a reference and carries an `$id`; in
+    // a `properties` map those are property names. The index registers
+    // every schema node, so that is the test.
+    const isSchema = state.nodeBase.has(node)
+    for (const k of Object.keys(node)) {
+      if (fail) return e
+      const v = node[k]
+      if (isSchema && (k === '$ref' || k === '$dynamicRef')) {
+        if (typeof v !== 'string') { fail = true; return e }
+        const t = k === '$ref' ? resolveRef(v, base, state) : resolveDynamic(v, base, chain)
+        if (t.node === undefined || t.node === null || (typeof t.node !== 'object' && typeof t.node !== 'boolean') || Array.isArray(t.node)) { fail = true; return e }
+        const target = entryFor(t.node, t.base, chain)
+        target.referenced = true
+        out.$ref = target
+        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))
+    }
+    return e
+  }
+  // A value under a keyword: a schema or a list is copied, anything else
+  // (a type name, a limit, a required name) is kept as it is.
+  const copyValue = (v, base, chain) => (v !== null && typeof v === 'object') || typeof v === 'boolean' ? entryFor(v, base, chain).copy : v
+  const rootBase = state.nodeBase.get(root)
+  const rootEntry = entryFor(root, rootBase, [rootBase])
+  if (fail) return null
+  const rootCopy = rootEntry.copy
+  const defsKey = root.$defs && typeof root.$defs === 'object' ? '$defs' : (root.definitions && typeof root.definitions === 'object' ? 'definitions' : '$defs')
+  const existing = {}
+  let n = 0
+  // Only a copy something refers to becomes a definition; the rest sit
+  // where they were copied.
+  for (const e of order) {
+    if (e === rootEntry) { e.name = '#'; continue }
+    if (!e.referenced) continue
+    let name
+    do { name = '__ata_dyn_' + n++ } while (Object.prototype.hasOwnProperty.call(existing, name))
+    e.name = name
+  }
+  // Write the names into the `$ref` slots.
+  const seen = new Set()
+  const fix = (o) => {
+    if (o === null || typeof o !== 'object' || seen.has(o)) return
+    seen.add(o)
+    if (Array.isArray(o)) { for (const x of o) fix(x); return }
+    for (const k of Object.keys(o)) {
+      const v = o[k]
+      if (k === '$ref' && v !== null && typeof v === 'object' && !Array.isArray(v) && typeof v.sig === 'string') {
+        o.$ref = v.name === '#' ? '#' : '#/' + defsKey + '/' + v.name
+        continue
+      }
+      if (!SKIP_VALUE_KEYS.has(k)) fix(v)
+    }
+  }
+  fix(rootCopy)
+  const defs = {}
+  for (const e of order) {
+    if (e === rootEntry || !e.referenced) continue
+    if (typeof e.copy === 'object') fix(e.copy)
+    defs[e.name] = e.copy
+  }
+  rootCopy[defsKey] = defs
+  return rootCopy
+}
+
 function normalizeRefsWalk(root, schemaMap) {
   const text = JSON.stringify(root)
   const hasRef = text.includes('"$ref"')
   _refFreeLength.set(root, hasRef ? -1 : text.length)
+  if (/"\$(?:recursiveRef|recursiveAnchor)"/.test(text)) return null
+  // A schema with dynamic references is unrolled by dynamic scope first; the
+  // result holds plain local references only.
+  if (/"\$(?:dynamicRef|dynamicAnchor)"/.test(text)) return expandDynamicScopes(root, schemaMap)
   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)
@@ -2277,14 +2449,16 @@ function normalizeRefsWalk(root, schemaMap) {
   const refTarget = new Map() // reference site node -> target node
   const visited = new Set()
   let fail = false
+  let dynamic = false
   const visit = (node) => {
     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 (node !== root && typeof node.$schema === 'string' && rootDialect !== null && node.$schema.replace(/#$/, '') !== rootDialect) { fail = true; return }
-    // A dynamic reference reached through another document means the same as
-    // one in the root: its target depends on the resources at run time.
-    if (node.$dynamicRef !== undefined || node.$dynamicAnchor !== undefined || node.$recursiveRef !== undefined || node.$recursiveAnchor !== undefined) { fail = true; return }
+    // A dynamic reference reached through another document is unrolled by
+    // scope the same way one in the root is (expandDynamicScopes, below).
+    if (node.$recursiveRef !== undefined || node.$recursiveAnchor !== undefined) { fail = true; return }
+    if (node.$dynamicRef !== undefined || node.$dynamicAnchor !== undefined) { dynamic = true; return }
     if (typeof node.$ref === 'string' && state.nodeBase.has(node)) {
       const base = state.nodeBase.get(node)
       const ref = node.$ref
@@ -2304,6 +2478,7 @@ function normalizeRefsWalk(root, schemaMap) {
   }
   visit(root)
   if (fail) return null
+  if (dynamic) return expandDynamicScopes(root, schemaMap)
   if (refTarget.size === 0) return root
   const defsKey = root.$defs && typeof root.$defs === 'object' ? '$defs' : (root.definitions && typeof root.definitions === 'object' ? 'definitions' : '$defs')
   const existing = root[defsKey] && typeof root[defsKey] === 'object' ? root[defsKey] : {}
@@ -2896,7 +3071,13 @@ function tryGenCombined(schema, access, ctx) {
 function _deferOrInline(ctx, lines, v, check) {
   // Deferring is only sound at the top level of the root function. Inside a
   // conditional applicator (dependentSchemas) the check must stay in its block.
-  if (v === 'd' && !ctx.condDepth) {
+  // Nor inside a verdict generated for a subschema (nestedGenCode, the inline
+  // annotation verdicts of run-time unevaluatedProperties): those lines go
+  // into a block or a function of their own and nothing flushes the deferred
+  // list for them, so a deferred check was dropped. A branch of an anyOf with
+  // `additionalProperties: { const: true }` at the root then read as holding
+  // for every object, and unevaluatedProperties accepted what it evaluated.
+  if (v === 'd' && !ctx.condDepth && !ctx.nestedBoolean) {
     if (!ctx.deferredChecks) ctx.deferredChecks = []
     ctx.deferredChecks.push(check)
   } else {
@@ -3420,11 +3601,20 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   // once, there. Only that model does: with unevaluatedProperties true or a
   // schema, skipping it here left anyOf unchecked and accepted a document no
   // branch matched.
-  if (schema.anyOf && !unevalChecksAnyOf(schema, ctx)) genAnyOfNode(schema, v, lines, ctx, knownType)
+  // Where unevaluatedProperties builds its evaluated set at run time, the
+  // annotation pass already decides each anyOf and oneOf branch, so the
+  // keywords' own blocks would decide them a second time: on a schema of
+  // nested references that doubled the cost of accepting a document. Their
+  // blocks go to the `else` of that pass instead, for a value that is not an
+  // object, which the pass does not look at and which they must still judge.
+  const nonObjApplicators = schema.unevaluatedProperties !== undefined && schema.additionalProperties === undefined &&
+    (Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf)) && unevalBuiltAtRuntime(schema, ctx) ? [] : null
+  const applicatorLines = nonObjApplicators || lines
+  if (schema.anyOf && !unevalChecksAnyOf(schema, ctx)) genAnyOfNode(schema, v, applicatorLines, 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, lines, ctx, knownType)
+  if (schema.oneOf) genOneOfNode(schema, v, applicatorLines, ctx, knownType)
 
   // not
   if (schema.not !== undefined) genNotNode(schema, v, lines, ctx, knownType)
@@ -3433,7 +3623,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   if (schema.if !== undefined) genIfNode(schema, v, lines, ctx, knownType)
 
   // unevaluatedProperties
-  if (schema.unevaluatedProperties !== undefined) genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, hoisted, earlyKeyCount)
+  if (schema.unevaluatedProperties !== undefined) genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, hoisted, earlyKeyCount, nonObjApplicators)
 
   // unevaluatedItems
   if (schema.unevaluatedItems !== undefined) genUnevaluatedItemsNode(schema, v, lines, ctx, knownType, isArr)
@@ -3763,7 +3953,9 @@ function genRefNode(schema, v, lines, ctx, knownType, hasSiblings) {
         // whatever function is compiling, carrying this def's key set.
         const outerDeferred = ctx.deferredChecks
         ctx.deferredChecks = null
-        genCode(ctx.rootDefs[defName], 'd', bodyLines, ctx)
+        const outerReuse = ctx.plainReuse
+        ctx.plainReuse = undefined
+        try { genCode(ctx.rootDefs[defName], 'd', bodyLines, ctx) } finally { ctx.plainReuse = outerReuse }
         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
@@ -3798,10 +3990,13 @@ function genRefNode(schema, v, lines, ctx, knownType, hasSiblings) {
         const outerDeferred = ctx.deferredChecks
         ctx.deferredChecks = null
         ctx.refStack.add(schema.$ref)
+        const outerReuse = ctx.plainReuse
+        ctx.plainReuse = undefined
         try {
           genCode(ctx.rootDefs[defName], 'd', bodyLines, ctx)
         } finally {
           ctx.refStack.delete(schema.$ref)
+          ctx.plainReuse = outerReuse
         }
         if (ctx.deferredChecks) for (const dc of ctx.deferredChecks) bodyLines.push(dc)
         ctx.deferredChecks = outerDeferred
@@ -4008,12 +4203,15 @@ function unevalBuiltAtRuntime(schema, ctx, r) {
   return r.dynamic && (r.allProps || !unevalPropsModeled(schema, ctx.schemaMap))
 }
 
-function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, hoisted, earlyKeyCount) {
+function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, hoisted, earlyKeyCount, nonObjApplicators) {
   const evalResult = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
   if (unevalBuiltAtRuntime(schema, ctx, evalResult)) {
-    genUnevalDynamicVerdict(schema, v, lines, ctx, isObj)
+    genUnevalDynamicVerdict(schema, v, lines, ctx, isObj, nonObjApplicators)
     return
   }
+  // genCodeNode moved the anyOf and oneOf blocks here only for the run-time
+  // form; any other outcome would leave them unwritten.
+  if (nonObjApplicators !== null && nonObjApplicators !== undefined) throw DECLINE
 
   if (evalResult.allProps || schema.unevaluatedProperties === true) {
     // All props evaluated or unevaluatedProperties:true — no-op
@@ -4955,7 +5153,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
   if (hasUnresolvableRef(schema, eRootDefs, eAnchors, schemaMap, new Set())) return null
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
-  const ctx = { varCounter: 0, helperCode: [], rootDefs: eRootDefs, shared: [], refStack: new Set(), schemaMap: schemaMap || null, anchors: eAnchors, rootSchema: inputSchema, userFormats: userFormats || null,
+  const ctx = { varCounter: 0, helperCode: [], rootDefs: eRootDefs, shared: [], refStack: new Set(), schemaMap: schemaMap || null, anchors: eAnchors, rootE: schema, rootSchema: inputSchema, userFormats: userFormats || null,
                 // Custom format checkers referenced by the body, bound as
                 // closure parameters below the way the other entry points do.
                 closureVars: [], closureVals: [],
@@ -5150,6 +5348,224 @@ function holdsRef (node, seen = new Set()) {
   return false
 }
 
+// Every `$ref` under `node`, outside the values of enum, const, default and
+// examples. Null when one is not a plain pointer into the root's definitions
+// (after prepareForCodegen those are what remain, besides `#` itself) or
+// when the node carries a scope keyword of its own, which would not mean the
+// same thing under a wrapper.
+const BRANCH_SCOPE_KEYS = new Set(['$id', '$anchor', '$dynamicAnchor', '$dynamicRef', '$defs', 'definitions', '$schema'])
+function branchRefsLocal (node, defsKey, seen) {
+  if (node === null || typeof node !== 'object') return true
+  if (seen.has(node)) return true
+  seen.add(node)
+  if (Array.isArray(node)) { for (const x of node) if (!branchRefsLocal(x, defsKey, seen)) return false; return true }
+  for (const k of Object.keys(node)) {
+    if (SKIP_VALUE_KEYS.has(k)) continue
+    if (BRANCH_SCOPE_KEYS.has(k)) return false
+    const v = node[k]
+    if (k === '$ref') { if (typeof v !== 'string' || !v.startsWith('#/' + defsKey + '/')) return false; continue }
+    if (!branchRefsLocal(v, defsKey, seen)) return false
+  }
+  return true
+}
+// One verdict function per branch, compiled on its own with the root's
+// definitions under it, or null when a branch cannot be wrapped that way
+// (then the site keeps its error functions for the decision). The
+// definitions themselves are checked once per root.
+const _defsLocal = new WeakMap()
+function compileBranchVerdicts (branches, ctx) {
+  const root = ctx.rootC
+  if (root === null || typeof root !== 'object') return null
+  const defsKey = root.$defs && typeof root.$defs === 'object' ? '$defs' : (root.definitions && typeof root.definitions === 'object' ? 'definitions' : null)
+  if (defsKey !== null) {
+    let ok = _defsLocal.get(root)
+    if (ok === undefined) { ok = branchRefsLocal(root[defsKey], defsKey, new Set()); _defsLocal.set(root, ok) }
+    if (!ok) return null
+  }
+  const out = []
+  for (const sub of branches) {
+    if (sub === true) { out.push(() => true); continue }
+    if (sub === false) { out.push(() => false); continue }
+    if (sub === null || typeof sub !== 'object' || Array.isArray(sub)) return null
+    if (!branchRefsLocal(sub, defsKey === null ? '$defs' : defsKey, new Set())) return null
+    const wrapped = Object.assign({}, sub)
+    if (defsKey !== null) wrapped[defsKey] = root[defsKey]
+    if (typeof ctx.rootSchema === 'object' && ctx.rootSchema !== null && typeof ctx.rootSchema.$schema === 'string') wrapped.$schema = ctx.rootSchema.$schema
+    let fn = null
+    try { fn = compileToJSCodegen(wrapped, ctx.schemaMap, ctx.userFormats) } catch (e) { if (e !== DECLINE) throw e }
+    if (typeof fn !== 'function') return null
+    out.push(fn)
+  }
+  return out
+}
+
+// A verdict for one subtree of the combined function, as a function in the
+// preamble, so the collecting code of that subtree runs only for a value the
+// verdict rejects. The collecting code is slower than the verdict on an
+// accepted value (it keeps paths, builds nothing it can avoid but tests more
+// than the verdict's cheapest-first order), so without this the whole
+// function was put behind one verdict of the whole document (`_VF`), and a
+// rejected document was validated twice in full. With a guard at every
+// array element and every object-valued property, an accepted value costs
+// its verdict and a rejected one costs its verdict plus the collection of
+// the subtree that failed. Only in the combined function, the runtime path;
+// null for a subtree whose verdict declines, is a leaf, or is too large.
+const GUARD_KEYS = ['oneOf', 'anyOf', 'allOf', '$ref', 'items', 'prefixItems', 'properties', 'patternProperties', 'additionalProperties', 'not', 'if', 'contains', 'dependentSchemas', 'dependencies', 'propertyNames', 'unevaluatedProperties', 'unevaluatedItems']
+const GUARD_MAX = 16 * 1024
+const GUARD_BUDGET = 512 * 1024
+// Whether a schema node is worth a guard of its own: it applies something
+// beyond leaf checks. A node whose children are themselves worth guarding is
+// not guarded; the guards go on the children. Guarding both ran the parent's
+// verdict in full and then, when it failed, every child's verdict again: on a
+// list of 1000 users with one bad one that was two verdicts of the list
+// before the one user was collected.
+const weighty = (n) => n !== null && typeof n === 'object' && !Array.isArray(n) && GUARD_KEYS.some((k) => n[k] !== undefined)
+function childrenWeighty (sub) {
+  if (weighty(sub.items)) return true
+  if (Array.isArray(sub.prefixItems) && sub.prefixItems.some(weighty)) return true
+  if (weighty(sub.additionalProperties)) return true
+  if (sub.properties && typeof sub.properties === 'object') for (const k of Object.keys(sub.properties)) if (weighty(sub.properties[k])) return true
+  if (sub.patternProperties && typeof sub.patternProperties === 'object') for (const k of Object.keys(sub.patternProperties)) if (weighty(sub.patternProperties[k])) return true
+  return false
+}
+// Below this much verdict source the guard is written into the function
+// itself as a labelled block (`gN:{...break gN...}`), not as a function it
+// calls: in the first thousands of calls of a process, before the optimizing
+// compiler has inlined anything, each call is paid in full, and a schema
+// with six small guards paid six. Above it the guard stays a function, so
+// one large subtree does not swell the function around it.
+const GUARD_INLINE_MAX = 2048
+function subtreeGuard (sub, ctx, gv) {
+  if (!ctx.inCombined || !weighty(sub) || childrenWeighty(sub)) return null
+  if ((ctx.guardChars || 0) >= GUARD_BUDGET) return null
+  // The verdict generator registers the definition functions it writes under
+  // `defFns`, and so does the error generator for the branch functions of
+  // this same program: shared, the verdict found the error generator's
+  // `_defE` function under the definition's name and called it with one
+  // argument. The guards keep a registry of their own.
+  if (!ctx.guardDefFns) ctx.guardDefFns = new Map()
+  const saved = snapshotCtx(ctx)
+  const outerDefFns = ctx.defFns
+  const outerShare = ctx.shareDefs
+  ctx.defFns = ctx.guardDefFns
+  // Definitions referenced from several places are written once, as
+  // functions in the preamble (the verdict generator's shared mode), not
+  // expanded into every guard that reaches them: expanded, the guards of a
+  // 25-definition API schema came to 55 KB of source in a 133 KB function,
+  // and a function that size reaches the optimizing compiler late.
+  ctx.shareDefs = true
+  try {
+    const bl = []
+    try { nestedGenCode(sub, gv, bl, ctx) } finally { ctx.defFns = outerDefFns; ctx.shareDefs = outerShare }
+    if (bl.length === 0) { restoreCtx(ctx, saved); return null }
+    const body = bl.join(';')
+    // The verdict generator's recursion names (`_validate`, the cycle guard
+    // state) are not this function's; a subtree that reaches them stays
+    // unguarded.
+    const added = ctx.preamble.slice(saved.get('preamble').n).join(';')
+    if (body.length > GUARD_MAX || body.includes(SP_PLACEHOLDER) || /\b(?:_validate|_stk|_sd|_sg|_CYC)\b/.test(body + added)) { restoreCtx(ctx, saved); return null }
+    ctx.guardChars = (ctx.guardChars || 0) + body.length
+    if (body.length <= GUARD_INLINE_MAX) return { body }
+    const name = `_vg${ctx.varCounter++}`
+    ctx.helperCode.push(`const ${name}=function(${gv}){${body};return true}`)
+    return { name }
+  } catch (e) {
+    if (e !== DECLINE) throw e
+    restoreCtx(ctx, saved)
+    return null
+  }
+}
+// The collecting code for `sub` at `v`, behind its guard when there is one.
+function genGuardedC (sub, v, pathExpr, lines, ctx, schemaPrefix) {
+  const gi = ctx.varCounter++
+  const gv = `_gv${gi}`
+  const g = subtreeGuard(sub, ctx, gv)
+  if (g === null) { genCodeC(sub, v, pathExpr, lines, ctx, schemaPrefix); return }
+  if (g.name !== undefined) lines.push(`if(!${g.name}(${v})){`)
+  else {
+    // The verdict's exits become jumps out of the block: a failure leaves
+    // the flag set, success clears it. replaceTopLevel keeps nested
+    // closures' returns as they are (see the hybrid rewrite).
+    lines.push(`{const ${gv}=${v};let _g${gi}=1;g${gi}:{${replaceTopLevel(g.body, `{_g${gi}=0;break g${gi}}`, `break g${gi}`)};_g${gi}=0}if(_g${gi}){`)
+  }
+  ctx.guardDepth = (ctx.guardDepth || 0) + 1
+  try { genCodeC(sub, v, pathExpr, lines, ctx, schemaPrefix) } finally { ctx.guardDepth-- }
+  lines.push(g.name !== undefined ? '}' : '}}')
+}
+
+// A branch's error-collecting body rewritten to count what it would have
+// collected: each `_e.push({keyword:'k',...})` becomes a count and a severity
+// (lib/branch-collapse.js, __ataScore), and the body returns the score the
+// collapse would compute from the errors. When no branch of a oneOf or anyOf
+// holds, the collapse reports the closest branch's errors; it used to run
+// every branch's error function to score them, building every branch's
+// errors to keep one branch's. Now the counting bodies score, and only the
+// closest branch's error function runs. Null for a body the rewrite cannot
+// follow (a shared definition call, a nested collapse, a push that is not a
+// literal); that site keeps the old path.
+function countingBody (body) {
+  // A nested oneOf or anyOf that does not hold is one collapsed error in the
+  // branch's list (keyword oneOf or anyOf, severity 4): its marked section,
+  // which would run the inner branches to build it, becomes that count.
+  // Two kinds of section: CB is one error whatever the branches would say;
+  // CU is a section the copy cannot score (the value is not the one the
+  // counts were taken for), so the copy answers -1 and the picker runs the
+  // branches as before.
+  while (true) {
+    const b1 = body.indexOf('/*CB*/'), b2 = body.indexOf('/*CU*/')
+    const b = b1 < 0 ? b2 : b2 < 0 ? b1 : Math.min(b1, b2)
+    if (b < 0) break
+    const unknown = b === b2
+    let depth = 1
+    let j = b + 6
+    while (j < body.length && depth > 0) {
+      if (body.startsWith('/*CB*/', j) || body.startsWith('/*CU*/', j)) { depth++; j += 6; continue }
+      if (body.startsWith('/*CE*/', j)) { depth--; j += 6; continue }
+      j++
+    }
+    if (depth !== 0) return null
+    body = body.slice(0, b) + (unknown ? 'return -1' : '(_n++,_s+=4)') + body.slice(j)
+  }
+  if (/\b(?:_defE\d|__ataCollapse|__ataMulti|_brf\d|_bsf\d)/.test(body)) return null
+  const SEV = require('./branch-collapse').SEVERITY
+  let out = ''
+  let i = 0
+  const head = 'const _e=[];'
+  if (!body.startsWith(head)) return null
+  out += 'let _n=0,_s=0;'
+  i = head.length
+  while (i < body.length) {
+    const ch = body[i]
+    if (ch === '"' || ch === "'" || ch === '`') { const j = skipString(body, i); out += body.slice(i, j); i = j; continue }
+    if (body.startsWith('_e.push(', i)) {
+      let j = i + 8
+      let depth = 1
+      while (j < body.length && depth > 0) {
+        const c = body[j]
+        if (c === '"' || c === "'" || c === '`') { j = skipString(body, j); continue }
+        if (c === '(' || c === '{' || c === '[') depth++
+        else if (c === ')' || c === '}' || c === ']') depth--
+        j++
+      }
+      if (depth !== 0) return null
+      const arg = body.slice(i + 8, j - 1)
+      // The literal may still carry its `code` (the shape pass strips it).
+      const m = /^\{(?:code:'ATA\d{4}',)?keyword:'([A-Za-z$][\w$]*)',/.exec(arg)
+      if (m === null) return null
+      out += `(_n++,_s+=${SEV[m[1]] || 4})`
+      i = j
+      continue
+    }
+    if (body.startsWith('return{valid:false,errors:_e}', i)) { out += 'return _n*100+_s'; i += 29; continue }
+    if (body.startsWith('return{valid:_e.length===0,errors:_e}', i)) { out += 'return _n*100+_s'; i += 37; continue }
+    if (body.startsWith('_e.length', i)) { out += '_n'; i += 9; continue }
+    out += ch
+    i++
+  }
+  if (/\b_e\b/.test(out.replace(/'[^']*'|"[^"]*"/g, ''))) return null
+  return out
+}
+
 function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaPrefix) {
   ctx.usesBranchCollapse = true
   const fi = ctx.varCounter++
@@ -5211,23 +5627,59 @@ 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=_ap(_e,${collapsed}))`
+    ? `const ${collapsed}=__ataCollapse('${branchKw}',${resArr},_pp${fi},'${branchSp}',${ord},_bt${fi});if(${collapsed})(_e=_ap(_A,_e,${collapsed},${apOrd(ctx, branchSp)}))`
     : `const ${collapsed}=__ataCollapse('${branchKw}',${resArr},_pp${fi},'${branchSp}',${ord},_bt${fi});if(${collapsed}){_e.push(${collapsed});if(!_all)return{valid:false,errors:_e}}`
+  // Score first, collect once (countingBody), in the combined function where
+  // the collapsed error is built in its final shape (no ordering key).
+  let noneReport = null
+  if (ctx.inCombined && (ctx.noOrdinal ? 'null' : '') === 'null') {
+    const cbs = fns.map((b) => b === '' ? 'return 0' : countingBody(b))
+    if (!cbs.some((c) => c === null)) {
+      const sfx = usesSp ? ',_sp' : ''
+      const code = branchKw === 'oneOf' ? 'ATA4001' : 'ATA4003'
+      // `code: ` with the space: the runtime shape strips this generator's own
+      // `code:'ATA....',` from the literals and keeps the collapse's, which
+      // the reader expects to carry it (see the shape pass below).
+      const lit = `{code: '${code}',keyword:'${branchKw}',instancePath:_pp${fi}||'',path:_pp${fi}||'',schemaPath:'${branchSp}',message:'value matched 0 of ${branches.length} ${branchKw} variants',params:{variants:${branches.length},closest:_bi${fi},closestName:_bt${fi}[_bi${fi}]||('variant '+(_bi${fi}+1))},branchErrors:_br${fi}.errors}`
+      // In a branch function the error joins that function's list (the
+      // combined function's `_ap` and ordering state are not its).
+      const push = ctx.inBranchFn ? `_e.push(${lit});if(!_all)return{valid:false,errors:_e}` : `(_e=_ap(_A,_e,${lit},${apOrd(ctx, branchSp)}))`
+      if (cbs.length === 1) {
+        // One branch is the closest one: nothing to score, no counting copy.
+        // Scoring it ran the branch a third time (verdict, count, errors).
+        noneReport = `{let _bi${fi}=0;const _br${fi}=${fnArr}[0](${v},_pp${fi},_all${sfx});${push}}`
+      } else {
+        ctx.helperCode.push(cbs.map((b, i) => `const _bsf${fi}_${i}=function(${params}){${b}}`).join(';'))
+        const picks = cbs.map((_, i) => `{const _s=_bsf${fi}_${i}(${v},_pp${fi},_all${sfx});if(_s<0)_ng${fi}=1;else if(_s<_bs${fi}){_bs${fi}=_s;_bi${fi}=${i}}}`).join('')
+        // A copy that could not score (-1): every branch runs, as before.
+        const noneOld = branchKw === 'anyOf'
+          ? `const ${resArr}=[];for(let _bi=0;_bi<${branches.length};_bi++){const _br=${call};${resArr}.push(_br.valid?{valid:false,errors:_br.errors}:_br)}${report}`
+          : `const ${resArr}=[];for(let _bi=0;_bi<${branches.length};_bi++)${resArr}.push(${call});${report}`
+        noneReport = `{let _bi${fi}=0,_bs${fi}=Infinity,_ng${fi}=0;${picks}if(_ng${fi}){${noneOld}}else{const _br${fi}=${fnArr}[_bi${fi}](${v},_pp${fi},_all${sfx});${push}}}`
+      }
+    }
+  }
   // The node's runtime unevaluatedProperties already counted how many of
   // these branches pass, through the annotation functions, which answer the
   // same validity. A oneOf with exactly one, an anyOf with any, holds and
   // reports nothing, so its branches are not run a second time to say so.
   // Only in the combined function proper, where that count is in scope.
-  const counted = ctx.inCombined && !ctx.inBranchFn && ctx.branchCounts ? ctx.branchCounts.get(branches) : undefined
+  // Inside a branch function only a factory-scope count (factoryCount) is
+  // in reach; the node's own counts are locals of the combined function.
+  const countedRaw = ctx.inCombined && ctx.branchCounts ? ctx.branchCounts.get(branches) : undefined
+  const counted = countedRaw !== undefined && (!ctx.inBranchFn || countedRaw.factory) ? countedRaw : undefined
   const same = counted !== undefined ? `${v}!==null&&typeof ${v}==='object'&&${counted.of}===${v}` : ''
   let guard = counted !== undefined
     ? (keyword === 'anyOf' ? `if(!(${same}&&${counted.count}>=1))` : `if(!(${same}&&${counted.count}===1))`)
     : ''
   // More than one oneOf branch passed: the error names them and carries no
   // branch errors, so it is built from the bits the count left.
-  if (guard !== '' && keyword === 'oneOf' && counted.mask && ctx.inCombined && !ctx.inBranchFn) {
+  if (guard !== '' && keyword === 'oneOf' && counted.mask && ctx.inCombined) {
     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=_ap(_e,__ataMulti(_pi${fi},${branches.length},${pp},'${branchSp}',${ord0})))}else if(!(${same}&&${counted.count}===1))`
+    const multiC = `__ataMulti(_pi${fi},${branches.length},${pp},'${branchSp}',${ord0})`
+    const pushC = ctx.inBranchFn ? `_e.push(${multiC});if(!_all)return{valid:false,errors:_e}` : `(_e=_ap(_A,_e,${multiC},${apOrd(ctx, branchSp)}))`
+    // The marked section is one error in a counting copy (countingBody).
+    guard = `if(${same}&&${counted.count}>1){/*CB*/const _pi${fi}=[];for(let _k=0;_k<${branches.length};_k++)if((${counted.mask}>>_k)&1)_pi${fi}.push(_k);${pushC}/*CE*/}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
@@ -5272,29 +5724,49 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
       restoreCtx(ctx, saved)
     }
   }
+  // In the combined function (the runtime path; a standalone module cannot
+  // carry a compiled function) a branch that holds a reference, or a site
+  // whose inline verdicts were too large, gets a verdict compiled on its own
+  // and handed in as a closure value: the branch with the root's definitions
+  // under it, through compileToJSCodegen, with its own shared definitions and
+  // its own regex engines. Without one, every branch's error function ran on
+  // every value the keyword saw, accepted or not: json-patch's six-way oneOf
+  // cost 1363 ns on a valid list of patches where its verdict costs 261.
+  if (vfArr === null && guard === '' && ctx.inCombined) {
+    const compiled = compileBranchVerdicts(branches, ctx)
+    if (compiled !== null) {
+      vfArr = `_bvf${fi}`
+      for (let i = 0; i < compiled.length; i++) { ctx.closureVars.push(`${vfArr}_${i}`); ctx.closureVals.push(compiled[i]) }
+    }
+  }
   if (vfArr !== null) {
     const L = branches.length
     const top = ctx.inCombined && !ctx.inBranchFn
     // An accepted document is still answered by the verdict first (see the
     // result shape in compileToJSCombined): that is the fastest path to it,
     // and dropping it measured 20 ns slower per accepted oneOf.
-    if (top) ctx.unguardedCollapse = true
+    if (top && !ctx.guardDepth) ctx.unguardedCollapse = true
     const tests = branches.map((_, i) => `${vfArr}_${i}(${v})`)
     if (keyword === 'anyOf') {
-      lines.push(`{const _pp${fi}=${pp};if(!(${tests.join('||')})){if(_all===0){_e.push(null);return{valid:false,errors:_e}}const ${resArr}=[];for(let _bi=0;_bi<${L};_bi++){const _br=${call};${resArr}.push(_br.valid?{valid:false,errors:_br.errors}:_br)}${report}}}`)
+      const none = noneReport !== null ? noneReport : `const ${resArr}=[];for(let _bi=0;_bi<${L};_bi++){const _br=${call};${resArr}.push(_br.valid?{valid:false,errors:_br.errors}:_br)}${report}`
+      // In a branch function the section a counting copy replaces is marked
+      // (countingBody): when the keyword does not hold, the error function
+      // reports one collapsed error, whatever the branches would say.
+      lines.push(`{const _pp${fi}=${pp};if(!(${tests.join('||')})){${top ? '' : '/*CB*/'}if(_all===0){_e.push(null);return{valid:false,errors:_e}}${none}${top ? '' : '/*CE*/'}}}`)
     } else {
       const mk = L <= 30
       const collect = mk
         ? `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=_ap(_e,${multi}))` : `_e.push(${multi});if(!_all)return{valid:false,errors:_e}`
+      const pushMulti = top ? `(_e=_ap(_A,_e,${multi},${apOrd(ctx, branchSp)}))` : `_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}}}}`)
+      const none = noneReport !== null ? noneReport : `const ${resArr}=[];for(let _bi=0;_bi<${L};_bi++)${resArr}.push(${call});${report}`
+      lines.push(`{const _pp${fi}=${pp};let _n${fi}=0${mk ? `,_m${fi}=0` : `,_pi${fi}=[]`};${count}if(_n${fi}!==1){${top ? '' : '/*CB*/'}if(_all===0){_e.push(null);return{valid:false,errors:_e}}if(_n${fi}>1){${collect}${pushMulti}}else{${none}}${top ? '' : '/*CE*/'}}}`)
     }
     return
   }
-  if (guard === '' && ctx.inCombined && !ctx.inBranchFn) ctx.unguardedCollapse = true
+  if (guard === '' && ctx.inCombined && !ctx.inBranchFn && !ctx.guardDepth) ctx.unguardedCollapse = true
   if (keyword === 'anyOf') {
     // anyOf reports nothing once a branch passes, so the branches are first
     // only asked whether they pass. They are called with `_all` set to 0, a
@@ -5308,12 +5780,24 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
     // no one read. Only when no branch passes do they run again with the
     // caller's `_all`, and the collapse sees them all, as before.
     const probe = `${fnArr}[_bi](${v},_pp${fi},0${usesSp ? ',_sp' : ''})`
-    lines.push(`${guard}{const _pp${fi}=${pp};let _bp${fi}=false;for(let _bi=0;_bi<${fnArr}.length;_bi++){if(${probe}.valid){_bp${fi}=true;break}}if(!_bp${fi}){if(_all===0){_e.push(null);return{valid:false,errors:_e}}const ${resArr}=[];for(let _bi=0;_bi<${fnArr}.length;_bi++){const _br=${call};${resArr}.push(_br.valid?{valid:false,errors:_br.errors}:_br)}${report}}}`)
+    const none = noneReport !== null ? noneReport : `const ${resArr}=[];for(let _bi=0;_bi<${fnArr}.length;_bi++){const _br=${call};${resArr}.push(_br.valid?{valid:false,errors:_br.errors}:_br)}${report}`
+    const probeOld = `let _bp${fi}=false;for(let _bi=0;_bi<${fnArr}.length;_bi++){if(${probe}.valid){_bp${fi}=true;break}}if(!_bp${fi}){if(_all===0){_e.push(null);return{valid:false,errors:_e}}${none}}`
+    // With a count: on the counted object the guard already said no branch
+    // held (CB, one error in a counting copy); on another object the branches
+    // are probed as before (CU, a counting copy cannot know).
+    if (counted !== undefined) lines.push(`${guard}{const _pp${fi}=${pp};if(${same}){/*CB*/if(_all===0){_e.push(null);return{valid:false,errors:_e}}${none}/*CE*/}else{/*CU*/${probeOld}/*CE*/}}`)
+    else lines.push(`${guard}{const _pp${fi}=${pp};${probeOld}}`)
   } else {
     // Asked only whether it passes (`_all` 0, see anyOf above), oneOf counts
     // the passing branches and answers; the branch errors of a probe are not
     // errors anyone reads and are not collapsed.
-    lines.push(`${guard}{const _pp${fi}=${pp};const ${resArr}=[];for(let _bi=0;_bi<${fnArr}.length;_bi++)${resArr}.push(${call});if(_all===0){let _n=0;for(const _r of ${resArr})if(_r.valid)_n++;if(_n!==1){_e.push(null);return{valid:false,errors:_e}}}else{${report}}}`)
+    // With a count from the node's unevaluatedProperties (`counted`), a count
+    // of zero on the counted object means no branch held, which is the case
+    // the closest-branch path answers without running every branch.
+    const oldO = `const ${resArr}=[];for(let _bi=0;_bi<${fnArr}.length;_bi++)${resArr}.push(${call});if(_all===0){let _n=0;for(const _r of ${resArr})if(_r.valid)_n++;if(_n!==1){_e.push(null);return{valid:false,errors:_e}}}else{${report}}`
+    const noneO = noneReport !== null ? noneReport : `const ${resArr}=[];for(let _bi=0;_bi<${fnArr}.length;_bi++)${resArr}.push(${call});${report}`
+    if (counted !== undefined) lines.push(`${guard}{const _pp${fi}=${pp};if(${same}){/*CB*/if(_all===0){_e.push(null);return{valid:false,errors:_e}}${noneO}/*CE*/}else{/*CU*/${oldO}/*CE*/}}`)
+    else lines.push(`${guard}{const _pp${fi}=${pp};${oldO}}`)
   }
 }
 
@@ -5340,19 +5824,60 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     ctx.regExpMap = new Map();
   }
   // $ref — resolve local and cross-schema refs
-  if (schema.$ref) {
-    // The reference is followed and the rest of the node is not compiled; a
-    // keyword beside it that validates would be dropped, so the node
-    // declines (as in genCodeCNode). Reached since unevaluatedProperties
-    // next to a $ref stopped declining the combined function, whose oneOf
-    // and anyOf branches come from this generator: a branch was taken as
-    // passing with its siblings unchecked.
-    for (const k of Object.keys(schema)) if (!REF_NEUTRAL_SIBLINGS.has(k) && !k.startsWith('x-')) throw DECLINE
-    // A self-reference cannot be expressed here yet: the root helper takes no
-    // path argument, so errors raised through it would carry the path of the
-    // root rather than of the value that failed. This used to fall through as
-    // a permissive no-op, which accepted whatever the reference guarded.
-    if (schema.$ref === '#') throw DECLINE
+  if (schema.$ref && !schema[REF_DONE]) {
+    // A keyword beside $ref that validates applies too (2020-12): the
+    // reference is written on its own, then the node again with the
+    // reference marked done, on a fresh copy that keeps `$ref` for the
+    // annotation readers, as genCodeCNode does. This used to decline, which
+    // kept the 2020-12 meta-schema (every vocabulary schema is a reference
+    // with siblings once unrolled by scope) off both error generators and on
+    // the interpreter for its errors, about 2 microseconds a rejection.
+    if (Object.keys(schema).some((k) => !REF_NEUTRAL_SIBLINGS.has(k) && !k.startsWith('x-'))) {
+      genCodeENode({ $ref: schema.$ref }, v, pathExpr, lines, ctx, schemaPrefix)
+      const rest = { ...schema }
+      Object.defineProperty(rest, REF_DONE, { value: true })
+      genCodeENode(rest, v, pathExpr, lines, ctx, schemaPrefix)
+      return
+    }
+    // A self-reference is a call to a helper over the root schema that takes
+    // the path and the schema path as arguments, as a definition on a cycle
+    // does below: the root helper takes no path, so errors raised through it
+    // carried the root's path, and this declined, which left a standalone
+    // module reporting one stub error for a schema with `$ref: "#"` anywhere
+    // in it. This used to fall through as a permissive no-op, which accepted
+    // whatever the reference guarded.
+    if (schema.$ref === '#') {
+      // The body comes from the prepared root (`rootE`), whose references
+      // are the resolvable ones; from the schema as given, a reference by
+      // `$id` resolved to nothing and the helper for the suite's recursive
+      // tree checked no node.
+      if (!ctx.rootE || typeof ctx.rootE !== 'object') throw DECLINE
+      if (!ctx.defFns) ctx.defFns = new Map()
+      let fnName = ctx.defFns.get('#')
+      if (!fnName) {
+        fnName = '_defE' + ctx.defFns.size + '_root'
+        ctx.defFns.set('#', fnName)
+        // The helper is its own function, so the references expanded in it
+        // start from nothing: inside the expansion of a definition that led
+        // here, the definition's own reference would otherwise read as
+        // already being expanded.
+        const bodyLines = []
+        const outerStack = ctx.refStack
+        ctx.refStack = new Set()
+        try { genCodeE(ctx.rootE, 'd', '_p', bodyLines, ctx, SP_PLACEHOLDER) } finally { ctx.refStack = outerStack }
+        let body = bodyLines.join('\n  ')
+        body = body.split(`'${SP_PLACEHOLDER}`).join(`_sp+'`).split(`"${SP_PLACEHOLDER}`).join(`_sp+"`)
+        if (body.includes(SP_PLACEHOLDER)) throw DECLINE
+        ctx.helperCode.push(
+          `const ${fnName}_s=new Set()\n  function ${fnName}(d,_p,_all,_e,_sp){\n  ` +
+            `if(_sg){if(typeof d!=='object'||d===null)return ${fnName}_b(d,_p,_all,_e,_sp);if(${fnName}_s.has(d))return;${fnName}_s.add(d);try{return ${fnName}_b(d,_p,_all,_e,_sp)}finally{${fnName}_s.delete(d)}}\n  ` +
+            `if(++_sd>${CYCLE_DEPTH})throw _CYC\n  const _r=${fnName}_b(d,_p,_all,_e,_sp)\n  _sd--\n  return _r\n  }\n  ` +
+            `function ${fnName}_b(d,_p,_all,_e,_sp){${body}}`,
+        )
+      }
+      lines.push(`${fnName}(${v},${pathExpr || '""'},_all,_e,'${schemaPrefix}');if(!_all&&_e.length)return{valid:false,errors:_e}`)
+      return
+    }
     const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
     if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
       const defName = m[1]
@@ -5392,7 +5917,10 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         lines.push(`${fnName}(${v},${pathExpr || '""'},_all,_e,'${schemaPrefix}');if(!_all&&_e.length)return{valid:false,errors:_e}`)
         return
       }
-      if (ctx.refStack.has(schema.$ref)) return
+      // A reference back into what is being expanded, on a cycle the
+      // definitions alone do not show (through the root, or another
+      // document): declined. Returning emitted nothing, which read as valid.
+      if (ctx.refStack.has(schema.$ref)) throw DECLINE
       ctx.refStack.add(schema.$ref)
       genCodeE(ctx.rootDefs[defName], v, pathExpr, lines, ctx, schemaPrefix)
       ctx.refStack.delete(schema.$ref)
@@ -5403,7 +5931,7 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       const entry = ctx.rootDefs && ctx.rootDefs[schema.$ref]
       const anchorTarget = entry && entry.raw ? entry.raw : (ctx.anchors && ctx.anchors[schema.$ref])
       if (anchorTarget) {
-        if (ctx.refStack.has(schema.$ref)) return
+        if (ctx.refStack.has(schema.$ref)) throw DECLINE
         ctx.refStack.add(schema.$ref)
         genCodeE(anchorTarget, v, pathExpr, lines, ctx, schemaPrefix)
         ctx.refStack.delete(schema.$ref)
@@ -5411,7 +5939,7 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       }
     }
     if (ctx.schemaMap && ctx.schemaMap.has(schema.$ref)) {
-      if (ctx.refStack.has(schema.$ref)) return
+      if (ctx.refStack.has(schema.$ref)) throw DECLINE
       ctx.refStack.add(schema.$ref)
       genCodeE(ctx.schemaMap.get(schema.$ref), v, pathExpr, lines, ctx, schemaPrefix)
       ctx.refStack.delete(schema.$ref)
@@ -5421,13 +5949,16 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (ctx.schemaMap && schema.$ref.includes('#') && !schema.$ref.startsWith('#')) {
       const r = resolveCrossSchemaRef(schema.$ref, ctx.schemaMap)
       if (r) {
-        if (ctx.refStack.has(schema.$ref)) return
+        if (ctx.refStack.has(schema.$ref)) throw DECLINE
         ctx.refStack.add(schema.$ref)
         genCodeE(r.schema, v, pathExpr, lines, ctx, schemaPrefix)
         ctx.refStack.delete(schema.$ref)
         return
       }
     }
+    // A reference none of the above resolved: declined. Falling through
+    // emitted nothing for it, which read as valid.
+    throw DECLINE
   }
 
   // $dynamicRef — resolve via anchors map
@@ -6019,8 +6550,63 @@ function sharedErr (lit, rootSchema) {
 // the value at `pathExpr`, which enrichment otherwise finds again by walking
 // 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.
+// The ordinal `_ap` is handed with each error of the combined function: the
+// error's place in schema order when its path is fixed at compile time, -1
+// when it is not (a path through a shared definition, a collapsed branch
+// error, an enriched error). `_ap` keeps whether the list is still in order
+// as it grows; a list that came out in order, which is most of them, is
+// handed out without the sort that looked every error's path up in a map.
+function apOrd (ctx, sp, coarse) {
+  // Inside a shared definition's function every error takes the ordinal of
+  // the reference that reached it, handed in as `_so`: errors behind one
+  // `$ref` sort where the reference is written, in the order the definition
+  // reports them.
+  if (typeof sp === 'string' && sp.includes(SP_PLACEHOLDER) && ctx && ctx.inDefC) return '_so'
+  if (typeof sp !== 'string' || sp.includes(SP_PLACEHOLDER) || sp.includes('+')) return -1
+  if (!ctx || !ctx.rootSchema) return -1
+  const path = unescapeSp(sp)
+  const o = ordinalFor(ctx.rootSchema, path)
+  if (typeof o !== 'number') return -1
+  // The reader orders by ordinal and, between equal ordinals, by the rank of
+  // the path (tieOrder in lib/rejections.js). Both are known here, so a site
+  // gets a token that assignOrdKeys turns into a dense integer in exactly that
+  // order when the program is assembled: two errors with one key are ones the
+  // reader keeps as they came. Keyed by the ordinal alone, two errors under
+  // one synthetic definition shared a key and sent every such list to the
+  // reader, which ranked the paths again: 45 percent of reading a list
+  // schema's two errors.
+  if (!ctx.ordSites) ctx.ordSites = new Map()
+  let site = ctx.ordSites.get(path)
+  if (site === undefined) { site = { i: ctx.ordSites.size, o, r: rankFor(ctx.rootSchema, path), key: -1 }; ctx.ordSites.set(path, site) }
+  // A coarse key, for the errors behind a reference into a shared definition
+  // (see `ap` in lib/combined-runtime.js): -(k+2), written when k is known.
+  return coarse ? `@@C${site.i}@@` : `@@O${site.i}@@`
+}
+
+// The dense keys of a program's error sites, in the reader's order: ordinal,
+// then rank as tieOrder compares it, element by element and the shorter
+// first; equal pairs share a key, and a site without a rank keeps -1, which
+// hands its list to the reader. Replaces the tokens apOrd wrote.
+function assignOrdKeys (ctx, src) {
+  if (!ctx.ordSites || ctx.ordSites.size === 0) return src
+  const sites = [...ctx.ordSites.values()]
+  const cmp = (a, b) => {
+    if (a.o !== b.o) return a.o - b.o
+    const m = Math.min(a.r.length, b.r.length)
+    for (let k = 0; k < m; k++) if (a.r[k] !== b.r[k]) return a.r[k] - b.r[k]
+    return a.r.length - b.r.length
+  }
+  const ranked = sites.filter((x) => x.r !== null).sort(cmp)
+  let key = 0
+  for (let i = 0; i < ranked.length; i++) { if (i > 0 && cmp(ranked[i - 1], ranked[i]) !== 0) key++; ranked[i].key = key }
+  return src.replace(/@@([OC])(\d+)@@/g, (_, t, i) => { const k = sites[+i].key; return String(t === 'O' || k < 0 ? k : -(k + 2)) })
+}
+
+// The error list and its order live in lib/combined-runtime.js (`ap`, `sr`):
+// `_A` is this program's state, reset at the top of each call.
+const AP_RESET = '_A.mo=true;_A.lo=-1;_A.on=0;'
 function errPushC(ctx, keyword, sp, pathExpr, paramsCode, msgCode, valueExpr, lean, paramsShared) {
-  if (!ctx.rich) return `(_e=_ap(_e,${lean}))`
+  if (!ctx.rich) return `(_e=_ap(_A,_e,${lean},${apOrd(ctx, sp)}))`
   if (!ctx.richMk) {
     ctx.richMk = true
     const { makeRich } = require('./enrich-site')
@@ -6036,7 +6622,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=_ap(_e,_mk(${siteVar},${pathExpr || '""'},${paramsShared || paramsCode},${msgCode},${valueExpr},d${rel ? ',_sp' : ''})))`
+  return `(_e=_ap(_A,_e,_mk(${siteVar},${pathExpr || '""'},${paramsShared || paramsCode},${msgCode},${valueExpr},d${rel ? ',_sp' : ''}),-1))`
 }
 
 function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts) {
@@ -6122,7 +6708,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
   // 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],
+  const ctx = { noOrdinal: !!(opts && opts.runtimeShape), rich: !!(opts && opts.rich), inCombined: true, hoisted: [], rootC: schema, varCounter: 0, preamble: [], helperCode: [], shared: [], closureVars: ['_cpLen', '_A', '_ap', '_sr', '_srX'], closureVals: [_cpLen, sharedRt().apState(), sharedRt().ap, sharedRt().sr, sharedRt().srX], sharedRuntime: true,
                 rootDefs: cRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: cAnchors, rootSchema: inputSchema, userFormats: userFormats || null }
   const lines = []
   try {
@@ -6143,6 +6729,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
     ctx.closureVars.push('_ER', '_EE', '_SRT', '_FB', '_VF')
     ctx.closureVals.push(opts.resultShape.Rejection, opts.resultShape.empty, opts.resultShape.sort, opts.resultShape.fallback, opts.resultShape.verdict || null)
   }
+  if (ctx.usesBranchCollapse) bindRt(ctx, ['__ataCollapse', '__ataMulti'])
   const closureNames = ctx.usesSafeRe ? [...ctx.closureVars, '__ataSafeRe'] : ctx.closureVars
   const closureArgs = ctx.usesSafeRe ? [...ctx.closureVals, compileSafe] : ctx.closureVals
   const closureParams = closureNames.join(',')
@@ -6161,7 +6748,6 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
   // the branch functions (this function collects everything), and the
   // runtime shape the error generator gives its literals, without code and
   // docUrl. The collapsed error itself keeps its code, as everywhere.
-  if (ctx.usesBranchCollapse) ctx.helperCode.push(require('./branch-collapse').embedSource())
   if (ctx.usesBranchCollapse && opts && opts.runtimeShape) {
     const shape = (src) => src.replace(/code:'ATA\d{4}',/g, '').replace(/,docUrl:'https:\/\/ata-validator\.com\/e\/ATA\d{4}'/g, '')
     for (let i = 0; i < ctx.helperCode.length; i++) ctx.helperCode[i] = shape(ctx.helperCode[i])
@@ -6182,7 +6768,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
     ctx.helperCode.push(`function _bodyC(d){${hoistDecl}${allDecl}let _e;\n  ${checks}\n  return _e}`)
     hoistDecl = ''
     allDecl = ''
-    checks = `_sd=0;try{_e=_bodyC(d)}catch(_err){if(_err!==_CYC)throw _err;_sg=true;${clears};try{_e=_bodyC(d)}finally{_sg=false}}`
+    checks = `_sd=0;try{_e=_bodyC(d)}catch(_err){if(_err!==_CYC)throw _err;_sg=true;${clears};${AP_RESET}try{_e=_bodyC(d)}finally{_sg=false}}`
   }
   // In the result shape this function is validate() itself, so a document
   // that makes it throw is answered by the caller's previous path instead
@@ -6195,18 +6781,21 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
     // Not when every collapse is guarded by a count (emitBranchCollapse): an
     // accepted document then runs no branch twice, and a rejected one would
     // pay for the verdict for nothing.
-    ? `try{${hoistDecl}${ctx.usesBranchCollapse && ctx.unguardedCollapse ? 'if(_VF!==null&&_VF(d))return{valid:true,data:d,errors:_EE};' : ''}${allDecl}let _e;\n  ` + checks +
+    ? `try{${hoistDecl}${ctx.usesBranchCollapse && ctx.unguardedCollapse ? 'if(_VF!==null&&_VF(d))return{valid:true,data:d,errors:_EE};' : ''}${allDecl}let _e;${AP_RESET}\n  ` + checks +
       // A collapsed branch error is presented even alone (its ordinal and
       // raw branch errors stay inside); otherwise only a list of two or more
       // needs ordering.
-      `\n  return _e?new _ER(${ctx.usesBranchCollapse ? '_SRT(_e)' : '_e.length>1?_SRT(_e):_e'}):{valid:true,data:d,errors:_EE}}catch(_x){return _FB(d)}`
-    : hoistDecl + allDecl + `let _e;\n  ` + checks + `\n  return _e?{valid:false,errors:_e}:R`
-  const helpers = ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : ''
+      `\n  return _e?new _ER(_A.mo?_e:${process.env.ATA_CHECK_SORT ? '_srX(_A,_e,_SRT)' : '_sr(_A,_e,_SRT)'}):{valid:true,data:d,errors:_EE}}catch(_x){return _FB(d)}`
+    : hoistDecl + allDecl + `let _e;${AP_RESET}\n  ` + checks + `\n  return _e?{valid:false,errors:_e}:R`
+  // The verdict generator's hoisted functions (subtreeGuard writes guards
+  // through it) come first: a oneOf branch it could not hoist was a closure
+  // built at every call of the guard, six per element of a json-patch list.
+  const helpers = (ctx.preamble.length ? ctx.preamble.join('\n  ') + '\n  ' : '') + (ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : '')
 
   try {
     if (typeof process !== 'undefined' && process.env && process.env.ATA_DUMP_CODEGEN) console.log('=== COMBINED CODEGEN ===\n' + helpers + inner + '\n=== CLOSURE VARS: ' + ctx.closureVars.length + ' ===')
     const factory = new Function('R' + (closureParams ? ',' + closureParams : ''),
-      `${helpers}return function(d){${inner}}`)
+      assignOrdKeys(ctx, `${helpers}return function _vC(d){${inner}}`))
     return factory(VALID_RESULT, ...closureArgs)
   } catch (e) {
     if (typeof process !== 'undefined' && process.env && process.env.ATA_DEBUG) console.error('compileToJSCombined error:', e.message, '\n', inner.slice(0, 500))
@@ -6262,11 +6851,32 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 // declares its own branch counts (genUnevaluatedDynamicC). The document root
 // comes in as `d` for the rich errors that read it. Not for a definition on a
 // reference cycle, which keeps its existing path. False when not shared.
+const COMBINED_DEF_FN_MIN = 160
+const _defOwnChars = new WeakMap()
+// The definition's own size, its annotations left out, measured once.
+function defOwnChars (def) {
+  if (def === null || typeof def !== 'object') return 0
+  let n = _defOwnChars.get(def)
+  if (n === undefined) {
+    n = 0
+    const walk = (x) => { if (x === null || typeof x !== 'object') { n += 6; return } if (Array.isArray(x)) { for (const y of x) walk(y); return } for (const k of Object.keys(x)) { if (SIZE_SKIPS.has(k)) continue; n += k.length + 4; walk(x[k]) } }
+    walk(def)
+    _defOwnChars.set(def, n)
+  }
+  return n
+}
+
 function emitSharedDefC(defName, v, pathExpr, lines, ctx, schemaPrefix) {
   if (!ctx.cyclicDefs) ctx.cyclicDefs = cyclicDefNames(ctx.rootDefs)
   if (!ctx.sharedDefs) ctx.sharedDefs = sharedDefNames(ctx.rootSchema, ctx.rootDefs)
   const cyclic = ctx.cyclicDefs.has(defName)
-  if (!cyclic && !ctx.sharedDefs.has(defName)) return false
+  // In the combined function every definition of some size is a function of
+  // its own, referenced once or not: expanded, a 25-definition API schema
+  // was one 122 KB function, which the optimizing compiler took tens of
+  // thousands of calls to reach, so its first twenty thousand answers cost
+  // 89 ns each where the hundred-thousandth costs 10. Functions the size of
+  // one definition tier up early, and the hot ones first.
+  if (!cyclic && !ctx.sharedDefs.has(defName) && !(ctx.inCombined && defOwnChars(ctx.rootDefs[defName]) >= COMBINED_DEF_FN_MIN)) return false
   emitDefFnC(defName, ctx.rootDefs[defName], cyclic, v, pathExpr, lines, ctx, schemaPrefix)
   return true
 }
@@ -6296,8 +6906,10 @@ function emitDefFnC(key, target, cyclic, v, pathExpr, lines, ctx, schemaPrefix)
     const bodyLines = []
     let hoisted
     try {
+      ctx.inDefC = (ctx.inDefC || 0) + 1
       genCodeC(target, '_dv', '_p', bodyLines, ctx, SP_PLACEHOLDER)
     } finally {
+      ctx.inDefC--
       hoisted = ctx.hoisted
       ctx.hoisted = outerHoisted
       ctx.refStack = outerRefs
@@ -6306,19 +6918,19 @@ function emitDefFnC(key, target, cyclic, v, pathExpr, lines, ctx, schemaPrefix)
     body = body.split(`'${SP_PLACEHOLDER}`).join(`_sp+'`).split(`"${SP_PLACEHOLDER}`).join(`_sp+"`)
     if (body.includes(SP_PLACEHOLDER)) throw DECLINE
     const decl = hoisted.length ? `let ${hoisted.map((n) => n + '=null').join(',')};` : ''
-    const fn = `function ${cyclic ? fnName + '_b' : fnName}(_dv,_p,_sp,d){const _all=true;${decl}let _e;\n  ${body}\n  return _e}`
+    const fn = `function ${cyclic ? fnName + '_b' : fnName}(_dv,_p,_sp,d,_so){const _all=true;${decl}let _e;\n  ${body}\n  return _e}`
     if (cyclic) {
       if (!ctx.cycFnsC) ctx.cycFnsC = []
       ctx.cycFnsC.push(fnName)
       ctx.helperCode.push(
-        `const ${fnName}_s=new Set()\n  function ${fnName}(_dv,_p,_sp,d){\n  ` +
-          `if(_sg){if(typeof _dv!=='object'||_dv===null)return ${fnName}_b(_dv,_p,_sp,d);if(${fnName}_s.has(_dv))return;${fnName}_s.add(_dv);try{return ${fnName}_b(_dv,_p,_sp,d)}finally{${fnName}_s.delete(_dv)}}\n  ` +
-          `if(++_sd>${CYCLE_DEPTH})throw _CYC\n  const _r=${fnName}_b(_dv,_p,_sp,d)\n  _sd--\n  return _r\n  }\n  ` + fn)
+        `const ${fnName}_s=new Set()\n  function ${fnName}(_dv,_p,_sp,d,_so){\n  ` +
+          `if(_sg){if(typeof _dv!=='object'||_dv===null)return ${fnName}_b(_dv,_p,_sp,d,_so);if(${fnName}_s.has(_dv))return;${fnName}_s.add(_dv);try{return ${fnName}_b(_dv,_p,_sp,d,_so)}finally{${fnName}_s.delete(_dv)}}\n  ` +
+          `if(++_sd>${CYCLE_DEPTH})throw _CYC\n  const _r=${fnName}_b(_dv,_p,_sp,d,_so)\n  _sd--\n  return _r\n  }\n  ` + fn)
     } else {
       ctx.helperCode.push(fn)
     }
   }
-  lines.push(`{const _r=${fnName}(${v},${pathExpr || '""'},'${schemaPrefix}',d);if(_r!==undefined){if(_e===undefined)_e=_r;else for(let _i=0;_i<_r.length;_i++)_e.push(_r[_i])}}`)
+  lines.push(`{const _r=${fnName}(${v},${pathExpr || '""'},'${schemaPrefix}',d,${apOrd(ctx, `${schemaPrefix}/$ref`, true)});if(_r!==undefined){if(_e===undefined)_e=_r;else for(let _i=0;_i<_r.length;_i++)_e.push(_r[_i])}}`)
 }
 
 const REF_DONE = Symbol('ata.refDone')
@@ -6459,12 +7071,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=_ap(_e,${errVar}))`
+        return `(_e=_ap(_A,_e,${errVar},${apOrd(ctx, sp)}))`
         }
       }
     }
     // Dynamic path (e.g., array index): inline as before
-    return `(_e=_ap(_e,{keyword:'${keyword}',instancePath:${pathExpr||'""'},schemaPath:'${sp}',params:${paramsCode},message:${msgCode}${ordinalField(ctx, sp)}}))`
+    return `(_e=_ap(_A,_e,{keyword:'${keyword}',instancePath:${pathExpr||'""'},schemaPath:'${sp}',params:${paramsCode},message:${msgCode}${ordinalField(ctx, sp)}},${apOrd(ctx, sp)}))`
   }
 
   // enum and const apply to a value of any type, so a value that fails
@@ -6554,7 +7166,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=_ap(_e,${errVar}))}`)
+        lines.push(`if(${check}){(_e=_ap(_A,_e,${errVar},${apOrd(ctx, `${schemaPrefix}/required`)}))}`)
       } 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)}'"}`)}}`)
       }
@@ -6568,7 +7180,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=_ap(_e,${errVar}))}`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){(_e=_ap(_A,_e,${errVar},${apOrd(ctx, `${schemaPrefix}/required`)}))}`)
       } 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)}'"}`)}}`)
       }
@@ -6667,8 +7279,12 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       const checks = propKeys.map(k => `_k${ci}[_i]!==${JSON.stringify(k)}`).join('&&') || 'true'
       body = `let _x${ci}=0;for(const _f${ci} in ${v}){if(${gate}){_x${ci}=1;break}}if(_x${ci}){${detail(checks)}}`
     } else {
-      const allowed = propKeys.map(k => JSON.stringify(k)).join(',')
-      body = `const _a${ci}=new Set([${allowed}]);let _x${ci}=0;for(const _f${ci} in ${v}){if(!_a${ci}.has(_f${ci})){_x${ci}=1;break}}if(_x${ci}){${detail(`!_a${ci}.has(_k${ci}[_i])`)}}`
+      // The name set lives in the closure, built once with the function: built
+      // in the body it was a 33-name Set on every call of this function, which
+      // is where a rejected npm-badges document spent most of its 701 ns.
+      ctx.closureVars.push(`_a${ci}`)
+      ctx.closureVals.push(new Set(propKeys))
+      body = `let _x${ci}=0;for(const _f${ci} in ${v}){if(!_a${ci}.has(_f${ci})){_x${ci}=1;break}}if(_x${ci}){${detail(`!_a${ci}.has(_k${ci}[_i])`)}}`
     }
     // When every declared property is required, a clean object has exactly the
     // declared keys: if the enumerated count equals the declared count and
@@ -6720,7 +7336,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=_ap(_e,${errVar}))}`)
+          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}&&!${ownKeyExpr(ctx, v, dep)}){(_e=_ap(_A,_e,${errVar},-1))}`)
         } 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)}'"}`)}}`)
         }
@@ -6736,16 +7352,16 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       if (requiredSet.has(key) && isObj) {
         // A hoisted local was already cleared if the value is only inherited.
         lines.push(`if(${pv}!==undefined${hoisted[key] ? '' : '&&' + ownGuard(ctx, v, key)}){`)
-        genCodeC(prop, pv, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
+        genGuardedC(prop, pv, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
         lines.push(`}`)
       } else if (isObj) {
         const oi = ctx.varCounter++
         lines.push(`{const _o${oi}=${v}[${JSON.stringify(key)}];if(_o${oi}!==undefined&&${ownGuard(ctx, v, key)}){`)
-        genCodeC(prop, `_o${oi}`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
+        genGuardedC(prop, `_o${oi}`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
         lines.push(`}}`)
       } else {
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
-        genCodeC(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
+        genGuardedC(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
         lines.push(`}`)
       }
     }
@@ -6775,7 +7391,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     ctx.varCounter++
     const childPath = childPathDynExpr(pathExpr, idx)
     lines.push(`if(Array.isArray(${v})){for(let ${idx}=${startIdx};${idx}<${v}.length;${idx}++){const ${elem}=${v}[${idx}]`)
-    genCodeC(schema.items, elem, childPath, lines, ctx, schemaPrefix+'/items')
+    genGuardedC(schema.items, elem, childPath, lines, ctx, schemaPrefix+'/items')
     lines.push(`}}`)
   }
 
@@ -6853,13 +7469,25 @@ function genUniqueItemsC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, is
 
 // The verdict form of genUnevaluatedDynamicC: the same set, built the same
 // way, and the answer false at the first key outside it.
-function genUnevalDynamicVerdict(schema, v, lines, ctx, isObj) {
-  if (schema.additionalProperties !== undefined) return
+function genUnevalDynamicVerdict(schema, v, lines, ctx, isObj, nonObjApplicators) {
+  if (schema.additionalProperties !== undefined) {
+    if (nonObjApplicators) throw DECLINE
+    return
+  }
   const ui = ctx.varCounter++
   const S = `_ev${ui}`
   const body = [`const ${S}=[]`]
   addLocalAnnotations(schema, v, S, body, ctx)
-  addTopApplicatorAnnotations(schema, v, S, body, ctx)
+  // With the anyOf and oneOf blocks moved here (see genCodeNode), their
+  // passing branches are counted by the annotation pass and judged from the
+  // count: a oneOf holds with exactly one, an anyOf with at least one.
+  const counts = nonObjApplicators ? { anyOf: `_ac${ui}`, oneOf: `_oc${ui}`, oneOfMask: null, of: null, verdict: true } : null
+  if (counts) body.push(`let ${counts.anyOf}=0,${counts.oneOf}=0`)
+  addTopApplicatorAnnotations(schema, v, S, body, ctx, counts)
+  if (counts) {
+    if (Array.isArray(schema.anyOf)) body.push(`if(${counts.anyOf}<1)return false`)
+    if (Array.isArray(schema.oneOf)) body.push(`if(${counts.oneOf}!==1)return false`)
+  }
   const kVar = `_uk${ui}`
   const up = schema.unevaluatedProperties
   if (up === false) {
@@ -6871,7 +7499,10 @@ function genUnevalDynamicVerdict(schema, v, lines, ctx, isObj) {
   } else {
     throw DECLINE
   }
-  lines.push(isObj ? `{${body.join(';')}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${body.join(';')}}`)
+  // A value that is not an object skips the pass, so the blocks moved here
+  // run for it in the `else`; a value known to be an object has no `else`.
+  const other = nonObjApplicators && nonObjApplicators.length && !isObj ? `else{${nonObjApplicators.join('\n  ')}}` : ''
+  lines.push(isObj ? `{${body.join(';')}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${body.join(';')}}${other}`)
 }
 
 // unevaluatedProperties where what is evaluated depends on which branches
@@ -6881,6 +7512,236 @@ function genUnevalDynamicVerdict(schema, v, lines, ctx, isObj) {
 // branch, an if, then or else, or a $ref target counts only when it passes,
 // a oneOf only when exactly one branch passes, and `not` never. Each branch is
 // asked through an annotation function (emitAnnot).
+// Run-time unevaluatedProperties written as straight-line code. The names a
+// node and its in-place applicators can evaluate are known when the code is
+// written (their `properties`), so the evaluated set is a bit per name in an
+// integer, each branch's verdict a labelled block, and a failed oneOf's
+// rollback the integer it started from. The annotation functions this
+// replaces (emitAnnot) pushed names onto an array, asked it with `includes`
+// for every key, and were a call per branch per level: ten functions and
+// twenty calls for the suite's nested-reference case, which in the first
+// thousands of calls of a process, before anything is inlined, cost 548 ns
+// against 131. Null when the shape is not modelled: names that are only known
+// at run time (patternProperties, additionalProperties), a nested
+// unevaluatedProperties, a reference cycle, more than 30 names, or too much
+// code; the annotation functions then stand in as before.
+const ANNOT_INLINE_MAX = 8192
+const ANNOT_NAME_MAX = 30
+const ANNOT_BLOCKERS = ['unevaluatedItems', '$dynamicRef', '$recursiveRef', 'dependencies']
+// Besides a bit per declared name, the mask has a bit per pattern of a
+// patternProperties (set when the subschema holding it holds: the keys it
+// matches are evaluated) and one bit, `all`, for a subschema that evaluates
+// every key when it holds (additionalProperties of any value, or a nested
+// `unevaluatedProperties: true`). A nested `unevaluatedProperties` that
+// checks something is not modelled.
+const ALL_BIT_KEY = '\u0000all'
+function annotSubs (node, ctx) {
+  const subs = []
+  for (const b of node.allOf || []) subs.push(b)
+  for (const b of node.anyOf || []) subs.push(b)
+  for (const b of node.oneOf || []) subs.push(b)
+  if (node.if !== undefined) subs.push(node.if)
+  if (node.then !== undefined) subs.push(node.then)
+  if (node.else !== undefined) subs.push(node.else)
+  if (node.dependentSchemas && typeof node.dependentSchemas === 'object') for (const ds of Object.values(node.dependentSchemas)) subs.push(ds)
+  if (typeof node.$ref === 'string') subs.push(refTargetFor(node.$ref, ctx))
+  return subs
+}
+function annotNames (node, ctx, names, seen, top) {
+  if (node === true || node === false) return true
+  if (node === null || typeof node !== 'object' || Array.isArray(node)) return false
+  if (seen.has(node)) return false
+  seen.add(node)
+  try {
+    for (const k of ANNOT_BLOCKERS) if (node[k] !== undefined) return false
+    if (!top && node.unevaluatedProperties !== undefined && node.unevaluatedProperties !== true) return false
+    const add = (key) => { if (!names.has(key)) { if (names.size >= ANNOT_NAME_MAX) return false; names.set(key, names.size) } return true }
+    if (node.properties && typeof node.properties === 'object') for (const k of Object.keys(node.properties)) if (!add(k)) return false
+    if (node.patternProperties && typeof node.patternProperties === 'object') for (const pat of Object.keys(node.patternProperties)) if (!add('/' + pat)) return false
+    if ((!top && node.additionalProperties !== undefined) || (!top && node.unevaluatedProperties === true)) if (!add(ALL_BIT_KEY)) return false
+    let subs
+    try { subs = annotSubs(node, ctx) } catch { return false }
+    for (const b of subs) if (!annotNames(b, ctx, names, seen, false)) return false
+    return true
+  } finally { seen.delete(node) }
+}
+// The bits a subschema's own keywords evaluate when it holds: its declared
+// names that are present, every pattern it declares, and `all` for a
+// subschema that evaluates every key.
+function ownBits (sub, v, names, ctx, t, top) {
+  const out = []
+  for (const k of Object.keys(sub.properties || {})) out.push(`if(${ownKeyExpr(ctx, v, k)})${t}|=${1 << names.get(k)}`)
+  let fixed = 0
+  for (const pat of Object.keys(sub.patternProperties || {})) fixed |= 1 << names.get('/' + pat)
+  if (!top && (sub.additionalProperties !== undefined || sub.unevaluatedProperties === true)) fixed |= 1 << names.get(ALL_BIT_KEY)
+  if (fixed !== 0) out.push(`${t}|=${fixed}`)
+  return out
+}
+// The test for one pattern bit against a key variable, a closure regex or a
+// fixed prefix test (fastPrefixCheck) as addLocalAnnotations writes them.
+function patternKeyTest (ctx, pat, kv) {
+  const fast = fastPrefixCheck(pat, kv)
+  if (fast) return fast
+  const ri = ctx.varCounter++
+  ctx.closureVars.push(`_re${ri}`)
+  ctx.closureVals.push(safeReClosure(ctx, pat))
+  return `_re${ri}.test(${kv})`
+}
+// Factory-scope count variables for one anyOf or oneOf array (by identity),
+// registered in ctx.branchCounts for emitBranchCollapse: `of` the object
+// they were counted for, `count` how many branches held, `mask` which (oneOf
+// up to 30 branches). Declared once per program; a stale value is never
+// taken, since every reader checks `of` against the value at hand.
+function factoryCount (ctx, arr, withMask) {
+  if (!ctx.inCombined) return null
+  if (!ctx.branchCounts) ctx.branchCounts = new Map()
+  const hit = ctx.branchCounts.get(arr)
+  if (hit !== undefined) return hit.factory ? hit : null
+  const id = ctx.varCounter++
+  const fc = { of: `_fa${id}`, count: `_fn${id}`, mask: withMask ? `_fm${id}` : null, factory: true }
+  ctx.helperCode.push(`let ${fc.of}=null,${fc.count}=0${withMask ? `,${fc.mask}=0` : ''}`)
+  ctx.branchCounts.set(arr, fc)
+  return fc
+}
+// Lines that set `ok` (declared by the caller, 1 or 0) for `sub` at `v`, an
+// object, and OR the names it evaluated into `tv` when it holds.
+function emitAnnotInline (sub, v, names, ctx, out, ok, tv) {
+  if (sub === true) { out.push(`${ok}=1`); return }
+  if (sub === false) { out.push(`${ok}=0`); return }
+  const id = ctx.varCounter++
+  const t = `_t${id}`
+  const local = {}
+  for (const k of Object.keys(sub)) if (!ANNOT_APPLICATORS.has(k)) setOwn(local, k, sub[k])
+  const vl = []
+  // The value is known to be an object here (the block runs for objects
+  // only), which the verdict is told when the branch does not say otherwise:
+  // told a type, the generator takes it for the value's and skips the
+  // branch's own `type`, so a `type: "string"` branch has to keep its check.
+  ctx.nestedBoolean = (ctx.nestedBoolean || 0) + 1
+  try { genCode(local, v, vl, ctx, local.type === undefined || local.type === 'object' ? 'object' : undefined) } finally { ctx.nestedBoolean-- }
+  out.push(`let ${t}=0;${ok}=1`)
+  if (vl.length) out.push(`a${id}:{${replaceTopLevel(vl.join(';'), `break a${id}`, `{${ok}=0;break a${id}}`)}}`)
+  if (sub.not !== undefined) {
+    const nl = []
+    nestedGenCode(sub.not, v, nl, ctx)
+    if (nl.length) out.push(`if(${ok}){let _nk${id}=1;n${id}:{${replaceTopLevel(nl.join(';'), `break n${id}`, `{_nk${id}=0;break n${id}}`)}};if(_nk${id})${ok}=0}`)
+    else out.push(`${ok}=0`)
+  }
+  const own = ownBits(sub, v, names, ctx, t, false)
+  if (own.length) out.push(`if(${ok}){${own.join(';')}}`)
+  let bi = 0
+  const child = (b) => { const o = `_ok${id}_${bi}`, tb = `_tb${id}_${bi}`; bi++; out.push(`let ${o}=1,${tb}=0`); emitAnnotInline(b, v, names, ctx, out, o, tb); return [o, tb] }
+  for (const b of sub.allOf || []) { const [o, tb] = child(b); out.push(`if(!${o})${ok}=0;else ${t}|=${tb}`) }
+  // The counts of a nested anyOf or oneOf go to factory-scope variables as
+  // well (factoryCount), where the keyword's own error code in a branch
+  // function, and the counting copies, read them instead of deciding the
+  // branches again: the suite's nested-reference case decided each branch
+  // four times over (this pass, the verdict closures, the counting copies,
+  // the chosen branch's error function).
+  if (Array.isArray(sub.anyOf)) {
+    const na = `_na${id}`
+    const fc = factoryCount(ctx, sub.anyOf, false)
+    out.push(`let ${na}=0${fc ? `;${fc.of}=${v};${fc.count}=0` : ''}`)
+    for (const b of sub.anyOf) { const [o, tb] = child(b); out.push(`if(${o}){${na}++;${t}|=${tb}${fc ? `;${fc.count}++` : ''}}`) }
+    out.push(`if(${na}===0)${ok}=0`)
+  }
+  if (Array.isArray(sub.oneOf)) {
+    const nc = `_nc${id}`, tc = `_tc${id}`
+    const fc = factoryCount(ctx, sub.oneOf, sub.oneOf.length <= 30)
+    out.push(`let ${nc}=0,${tc}=0${fc ? `;${fc.of}=${v};${fc.count}=0${fc.mask ? `;${fc.mask}=0` : ''}` : ''}`)
+    sub.oneOf.forEach((b, i) => { const [o, tb] = child(b); out.push(`if(${o}){${nc}++;${tc}=${tb}${fc ? `;${fc.count}++${fc.mask ? `;${fc.mask}|=${1 << i}` : ''}` : ''}}`) })
+    out.push(`if(${nc}===1)${t}|=${tc};else ${ok}=0`)
+  }
+  if (sub.if !== undefined) {
+    const [oi, ti] = child(sub.if)
+    const thenPart = []
+    if (sub.then !== undefined) { const saved = out.length; const [ot, tt] = child(sub.then); thenPart.push(...out.splice(saved)); thenPart.push(`if(!${ot})${ok}=0;else ${t}|=${tt}`) }
+    const elsePart = []
+    if (sub.else !== undefined) { const saved = out.length; const [oe, te] = child(sub.else); elsePart.push(...out.splice(saved)); elsePart.push(`if(!${oe})${ok}=0;else ${t}|=${te}`) }
+    out.push(`if(${oi}){${t}|=${ti};${thenPart.join(';')}}else{${elsePart.join(';')}}`)
+  }
+  if (sub.dependentSchemas && typeof sub.dependentSchemas === 'object') {
+    for (const [k, ds] of Object.entries(sub.dependentSchemas)) { const saved = out.length; const [o, tb] = child(ds); const body = out.splice(saved); out.push(`if(${ownKeyExpr(ctx, v, k)}){${body.join(';')};if(!${o})${ok}=0;else ${t}|=${tb}}`) }
+  }
+  if (typeof sub.$ref === 'string') { const [o, tb] = child(refTargetFor(sub.$ref, ctx)); out.push(`if(!${o})${ok}=0;else ${t}|=${tb}`) }
+  out.push(`if(${ok})${tv}|=${t}`)
+}
+// The whole run-time unevaluatedProperties block for `schema` at `v`, or
+// null. `counts` as in genUnevaluatedDynamicC: how many anyOf and oneOf
+// branches held, for the keywords' own code to read.
+function inlineUnevalBlock (schema, v, pathExpr, ctx, schemaPrefix, fail, counts) {
+  const names = new Map()
+  if (!annotNames(schema, ctx, names, new Set(), true)) return null
+  const saved = snapshotCtx(ctx)
+  try {
+    const id = ctx.varCounter++
+    const m = `_m${id}`
+    const out = [`let ${m}=0`]
+    // One prototype flag for the object, read by every presence test below.
+    if (!ctx.plainOf) ctx.plainOf = new Map()
+    const prevPk = ctx.plainOf.get(v)
+    const pk = prevPk !== undefined ? prevPk : `_pk${id}`
+    const prevReuse = ctx.plainReuse
+    if (prevPk === undefined) { out.push(`const ${pk}=${protoIs(ctx, v)}`); ctx.plainOf.set(v, pk); (ctx.plainUsed || (ctx.plainUsed = new Set())).add(pk) }
+    ctx.plainReuse = v
+    out.push(...ownBits(schema, v, names, ctx, m, true))
+    let bi = 0
+    const child = (b) => { const o = `_ok${id}_${bi}`, tb = `_tb${id}_${bi}`; bi++; out.push(`let ${o}=1,${tb}=0`); emitAnnotInline(b, v, names, ctx, out, o, tb); return [o, tb] }
+    for (const b of schema.allOf || []) { const [, tb] = child(b); out.push(`${m}|=${tb}`) }
+    if (Array.isArray(schema.anyOf)) {
+      const na = counts ? counts.anyOf : `_na${id}`
+      out.push(counts ? `${na}=0` : `let ${na}=0`)
+      for (const b of schema.anyOf) { const [o, tb] = child(b); out.push(`if(${o}){${na}++;${m}|=${tb}}`) }
+    }
+    if (Array.isArray(schema.oneOf)) {
+      const nc = counts ? counts.oneOf : `_nc${id}`, tc = `_tc${id}`
+      out.push(counts ? `${nc}=0;let ${tc}=0` : `let ${nc}=0,${tc}=0`)
+      schema.oneOf.forEach((b, i) => { const [o, tb] = child(b); out.push(`if(${o}){${nc}++;${tc}=${tb};${counts && counts.oneOfMask && schema.oneOf.length <= 30 ? `${counts.oneOfMask}|=${1 << i};` : ''}}`) })
+      out.push(`if(${nc}===1)${m}|=${tc}`)
+    }
+    if (schema.if !== undefined) {
+      const [oi, ti] = child(schema.if)
+      const thenPart = []
+      if (schema.then !== undefined) { const sv = out.length; const [ot, tt] = child(schema.then); thenPart.push(...out.splice(sv)); thenPart.push(`if(${ot})${m}|=${tt}`) }
+      const elsePart = []
+      if (schema.else !== undefined) { const sv = out.length; const [oe, te] = child(schema.else); elsePart.push(...out.splice(sv)); elsePart.push(`if(${oe})${m}|=${te}`) }
+      out.push(`if(${oi}){${m}|=${ti};${thenPart.join(';')}}else{${elsePart.join(';')}}`)
+    }
+    if (schema.dependentSchemas && typeof schema.dependentSchemas === 'object') {
+      for (const [k, ds] of Object.entries(schema.dependentSchemas)) { const sv = out.length; const [o, tb] = child(ds); const body = out.splice(sv); out.push(`if(${ownKeyExpr(ctx, v, k)}){${body.join(';')};if(${o})${m}|=${tb}}`) }
+    }
+    if (typeof schema.$ref === 'string') { const [o, tb] = child(refTargetFor(schema.$ref, ctx)); out.push(`if(${o})${m}|=${tb}`) }
+    // What is left: every own key whose bit is not set.
+    const kVar = `_uk${id}`
+    const cases = [...names].filter(([k]) => k !== ALL_BIT_KEY && k[0] !== '/').map(([k, i]) => `case ${JSON.stringify(k)}:_ub${id}=${1 << i};break`).join(';')
+    const allBit = names.has(ALL_BIT_KEY) ? `if((${m}&${1 << names.get(ALL_BIT_KEY)})!==0)continue;` : ''
+    const patBits = [...names].filter(([k]) => k[0] === '/').map(([k, i]) => `if((${m}&${1 << i})!==0&&${patternKeyTest(ctx, k.slice(1), `_uk${id}`)})continue;`).join('')
+    const up = schema.unevaluatedProperties
+    let body
+    if (up === false) {
+      body = fail('unevaluatedProperties', 'unevaluatedProperties', `{unevaluatedProperty:${kVar}}`, "'must NOT have unevaluated properties'")
+    } else if (typeof up === 'object' && up !== null) {
+      const pe = emitPtrEsc(ctx)
+      const p = pathExpr ? `${pathExpr}+'/'+${pe}(${kVar})` : `'/'+${pe}(${kVar})`
+      const sub = []
+      genCodeC(up, `${v}[${kVar}]`, p, sub, ctx, schemaPrefix + '/unevaluatedProperties')
+      body = sub.join('\n  ')
+    } else {
+      throw DECLINE
+    }
+    if (body) out.push(`for(const ${kVar} in ${v}){if(!${ownKeyExpr(ctx, v, kVar).split(JSON.stringify(kVar)).join(kVar)})continue;let _ub${id}=0;switch(${kVar}){${cases}}if(_ub${id}!==0&&(${m}&_ub${id})!==0)continue;${allBit}${patBits}${body}}`)
+    const text = out.join(';')
+    ctx.plainReuse = prevReuse
+    if (prevPk === undefined) ctx.plainOf.delete(v)
+    if (text.length > ANNOT_INLINE_MAX || /\b(?:_validate|_stk|_sd|_sg|_CYC)\b/.test(text)) { restoreCtx(ctx, saved); return null }
+    return text
+  } catch (e) {
+    if (e !== DECLINE) throw e
+    restoreCtx(ctx, saved)
+    return null
+  }
+}
+
 function genUnevaluatedDynamicC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj) {
   // additionalProperties evaluates every key the others do not, pass or fail.
   if (schema.additionalProperties !== undefined) return
@@ -6904,6 +7765,12 @@ function genUnevaluatedDynamicC(schema, v, pathExpr, lines, ctx, schemaPrefix, f
     if (Array.isArray(schema.anyOf)) ctx.branchCounts.set(schema.anyOf, { of: counts.of, count: counts.anyOf, mask: null })
     if (Array.isArray(schema.oneOf)) ctx.branchCounts.set(schema.oneOf, { of: counts.of, count: counts.oneOf, mask: schema.oneOf.length <= 30 ? counts.oneOfMask : null })
   }
+  const inline = inlineUnevalBlock(schema, v, pathExpr, ctx, schemaPrefix, fail, counts)
+  if (inline !== null) {
+    const pre = share ? `${counts.of}=${v};${counts.oneOfMask}=0;` : ''
+    lines.push(isObj ? `{${pre}${inline}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${pre}${inline}}`)
+    return
+  }
   addTopApplicatorAnnotations(schema, v, S, body, ctx, counts)
   const kVar = `_uk${ui}`
   const up = schema.unevaluatedProperties
@@ -6966,7 +7833,9 @@ function addTopApplicatorAnnotations(node, v, S, out, ctx, counts) {
     const t = counts ? counts.oneOf : `_oc${ctx.varCounter++}`
     // Which branches passed, as bits, for a collapse that has to name them.
     const mask = counts && node.oneOf.length <= 30 ? counts.oneOfMask : null
-    out.push(`{const ${t}m=${S}.length;${counts ? '' : 'let '}${t}=0;${node.oneOf.map((b, i) => `if(${emitAnnot(b, ctx)}(${v},${S})){${t}++;${mask ? `${mask}|=${1 << i};` : ''}}`).join('')}if(${t}!==1)_rb(${S},${t}m)}`)
+    // In a verdict (counts.verdict), a second passing branch is the answer.
+    const over = counts && counts.verdict ? `if(${t}>1)return false;` : ''
+    out.push(`{const ${t}m=${S}.length;${counts ? '' : 'let '}${t}=0;${node.oneOf.map((b, i) => `if(${emitAnnot(b, ctx)}(${v},${S})){${t}++;${over}${mask ? `${mask}|=${1 << i};` : ''}}`).join('')}if(${t}!==1)_rb(${S},${t}m)}`)
   }
   if (node.if !== undefined) {
     const thenCall = node.then !== undefined ? `${emitAnnot(node.then, ctx)}(${v},${S})` : ''
@@ -7003,7 +7872,8 @@ function emitAnnot(sub, ctx) {
   if (sub === null || typeof sub !== 'object') throw DECLINE
   if (!ctx.annFns) {
     ctx.annFns = new Map()
-    ;(ctx.preamble || ctx.helperCode).push('function _anT(){return true}function _anF(){return false}function _rb(S,m){if(S.length!==m)S.length=m}')
+    if (ctx.sharedRuntime) bindRt(ctx, ['_anT', '_anF', '_rb'])
+    else (ctx.preamble || ctx.helperCode).push('function _anT(){return true}function _anF(){return false}function _rb(S,m){if(S.length!==m)S.length=m}')
   }
   const hit = ctx.annFns.get(sub)
   if (hit !== undefined) {
@@ -7035,7 +7905,8 @@ function emitAnnot(sub, ctx) {
   const failOut = '{_rb(S,_m);return false}'
   for (const b of sub.allOf || []) body.push(`if(!${emitAnnot(b, ctx)}(d,S))${failOut}`)
   if (Array.isArray(sub.anyOf)) body.push(`{let _a=false;${sub.anyOf.map((b) => `if(${emitAnnot(b, ctx)}(d,S))_a=true;`).join('')}if(!_a)${failOut}}`)
-  if (Array.isArray(sub.oneOf)) body.push(`{let _c=0;${sub.oneOf.map((b) => `if(${emitAnnot(b, ctx)}(d,S))_c++;`).join('')}if(_c!==1)${failOut}}`)
+  // A second passing branch settles the oneOf; the rest are not run.
+  if (Array.isArray(sub.oneOf)) body.push(`{let _c=0;${sub.oneOf.map((b) => `if(${emitAnnot(b, ctx)}(d,S)&&++_c>1)${failOut}`).join('')}if(_c!==1)${failOut}}`)
   if (sub.if !== undefined) {
     const thenCheck = sub.then !== undefined ? `if(!${emitAnnot(sub.then, ctx)}(d,S))${failOut}` : ''
     const elseCheck = sub.else !== undefined ? `if(!${emitAnnot(sub.else, ctx)}(d,S))${failOut}` : ''
@@ -7076,9 +7947,153 @@ function emitAnnot(sub, ctx) {
 // subschema marks them only when it passes (emitAnnotI); what is left must
 // pass unevaluatedItems. `false` reports once, at the first position left,
 // as the interpreter does.
+// Run-time unevaluatedItems written as straight-line code, the way
+// inlineUnevalBlock writes unevaluatedProperties. Without `contains` the
+// positions a node and its in-place applicators evaluate are a prefix: items
+// evaluates every position, prefixItems the first p, a nested
+// `unevaluatedItems: true` every position once its subschema holds; the
+// record is one integer, merged with max where a branch holds, and what is
+// left starts at that index. `contains` (positions that are not a prefix), a
+// tuple `items`, a nested unevaluatedItems that checks something, dynamic
+// references and reference cycles keep the annotation functions.
+const ANNOT_I_BLOCKERS = ['contains', 'additionalItems', '$dynamicRef', '$recursiveRef', 'dependencies']
+function annotItemsFit (node, ctx, seen, top) {
+  if (node === true || node === false) return true
+  if (node === null || typeof node !== 'object' || Array.isArray(node)) return false
+  if (seen.has(node)) return false
+  seen.add(node)
+  try {
+    for (const k of ANNOT_I_BLOCKERS) if (node[k] !== undefined) return false
+    if (Array.isArray(node.items)) return false
+    if (!top && node.unevaluatedItems !== undefined && node.unevaluatedItems !== true) return false
+    if (node.unevaluatedProperties !== undefined && node.unevaluatedProperties !== true) return false
+    let subs
+    try { subs = annotSubs(node, ctx) } catch { return false }
+    for (const b of subs) if (!annotItemsFit(b, ctx, seen, false)) return false
+    return true
+  } finally { seen.delete(node) }
+}
+// The positions a node's own keywords evaluate, as an expression of the
+// array length `len`: null when none.
+function ownPrefix (node, len, top) {
+  if (node.items !== undefined) return len
+  if (!top && node.unevaluatedItems === true) return len
+  if (Array.isArray(node.prefixItems) && node.prefixItems.length) return `(${len}<${node.prefixItems.length}?${len}:${node.prefixItems.length})`
+  return null
+}
+// Lines that set `ok` for `sub` at `v`, an array of length `len`, and raise
+// `tn` to the positions it evaluated when it holds.
+function emitAnnotInlineI (sub, v, len, ctx, out, ok, tn) {
+  if (sub === true) { out.push(`${ok}=1`); return }
+  if (sub === false) { out.push(`${ok}=0`); return }
+  const id = ctx.varCounter++
+  const t = `_t${id}`
+  const local = {}
+  for (const k of Object.keys(sub)) if (!ANNOT_ITEM_APPLICATORS.has(k)) setOwn(local, k, sub[k])
+  const vl = []
+  ctx.nestedBoolean = (ctx.nestedBoolean || 0) + 1
+  try { genCode(local, v, vl, ctx, local.type === undefined || local.type === 'array' ? 'array' : undefined) } finally { ctx.nestedBoolean-- }
+  out.push(`let ${t}=0;${ok}=1`)
+  if (vl.length) out.push(`a${id}:{${replaceTopLevel(vl.join(';'), `break a${id}`, `{${ok}=0;break a${id}}`)}}`)
+  if (sub.not !== undefined) {
+    const nl = []
+    nestedGenCode(sub.not, v, nl, ctx)
+    if (nl.length) out.push(`if(${ok}){let _nk${id}=1;n${id}:{${replaceTopLevel(nl.join(';'), `break n${id}`, `{_nk${id}=0;break n${id}}`)}};if(_nk${id})${ok}=0}`)
+    else out.push(`${ok}=0`)
+  }
+  const own = ownPrefix(sub, len, false)
+  if (own !== null) out.push(`if(${ok})${t}=${own}`)
+  let bi = 0
+  const child = (b) => { const o = `_ok${id}_${bi}`, tb = `_tb${id}_${bi}`; bi++; out.push(`let ${o}=1,${tb}=0`); emitAnnotInlineI(b, v, len, ctx, out, o, tb); return [o, tb] }
+  const raise = (tb) => `if(${tb}>${t})${t}=${tb}`
+  for (const b of sub.allOf || []) { const [o, tb] = child(b); out.push(`if(!${o})${ok}=0;else ${raise(tb)}`) }
+  if (Array.isArray(sub.anyOf)) {
+    const na = `_na${id}`
+    const fc = factoryCount(ctx, sub.anyOf, false)
+    out.push(`let ${na}=0${fc ? `;${fc.of}=${v};${fc.count}=0` : ''}`)
+    for (const b of sub.anyOf) { const [o, tb] = child(b); out.push(`if(${o}){${na}++;${raise(tb)}${fc ? `;${fc.count}++` : ''}}`) }
+    out.push(`if(${na}===0)${ok}=0`)
+  }
+  if (Array.isArray(sub.oneOf)) {
+    const nc = `_nc${id}`, tc = `_tc${id}`
+    const fc = factoryCount(ctx, sub.oneOf, sub.oneOf.length <= 30)
+    out.push(`let ${nc}=0,${tc}=0${fc ? `;${fc.of}=${v};${fc.count}=0${fc.mask ? `;${fc.mask}=0` : ''}` : ''}`)
+    sub.oneOf.forEach((b, i) => { const [o, tb] = child(b); out.push(`if(${o}){${nc}++;${tc}=${tb}${fc ? `;${fc.count}++${fc.mask ? `;${fc.mask}|=${1 << i}` : ''}` : ''}}`) })
+    out.push(`if(${nc}===1){${raise(tc)}}else ${ok}=0`)
+  }
+  if (sub.if !== undefined) {
+    const [oi, ti] = child(sub.if)
+    const thenPart = []
+    if (sub.then !== undefined) { const sv = out.length; const [ot, tt] = child(sub.then); thenPart.push(...out.splice(sv)); thenPart.push(`if(!${ot})${ok}=0;else ${raise(tt)}`) }
+    const elsePart = []
+    if (sub.else !== undefined) { const sv = out.length; const [oe, te] = child(sub.else); elsePart.push(...out.splice(sv)); elsePart.push(`if(!${oe})${ok}=0;else ${raise(te)}`) }
+    out.push(`if(${oi}){${raise(ti)};${thenPart.join(';')}}else{${elsePart.join(';')}}`)
+  }
+  if (typeof sub.$ref === 'string') { const [o, tb] = child(refTargetFor(sub.$ref, ctx)); out.push(`if(!${o})${ok}=0;else ${raise(tb)}`) }
+  out.push(`if(${ok}&&${t}>${tn})${tn}=${t}`)
+}
+function inlineUnevalItemsBlock (schema, v, pathExpr, ctx, schemaPrefix, fail) {
+  if (!ctx.inCombined || !annotItemsFit(schema, ctx, new Set(), true)) return null
+  const saved = snapshotCtx(ctx)
+  try {
+    const id = ctx.varCounter++
+    const n = `_un${id}`, len = `_ul${id}`
+    const out = [`const ${len}=${v}.length;let ${n}=0`]
+    const own = ownPrefix(schema, len, true)
+    if (own !== null) out.push(`${n}=${own}`)
+    let bi = 0
+    const child = (b) => { const o = `_ok${id}_${bi}`, tb = `_tb${id}_${bi}`; bi++; out.push(`let ${o}=1,${tb}=0`); emitAnnotInlineI(b, v, len, ctx, out, o, tb); return [o, tb] }
+    const raise = (tb) => `if(${tb}>${n})${n}=${tb}`
+    for (const b of schema.allOf || []) { const [, tb] = child(b); out.push(raise(tb)) }
+    if (Array.isArray(schema.anyOf)) {
+      const fc = factoryCount(ctx, schema.anyOf, false)
+      if (fc) out.push(`${fc.of}=${v};${fc.count}=0`)
+      for (const b of schema.anyOf) { const [o, tb] = child(b); out.push(`if(${o}){${raise(tb)}${fc ? `;${fc.count}++` : ''}}`) }
+    }
+    if (Array.isArray(schema.oneOf)) {
+      const fc = factoryCount(ctx, schema.oneOf, schema.oneOf.length <= 30)
+      const nc = `_nc${id}`, tc = `_tc${id}`
+      out.push(`let ${nc}=0,${tc}=0${fc ? `;${fc.of}=${v};${fc.count}=0${fc.mask ? `;${fc.mask}=0` : ''}` : ''}`)
+      schema.oneOf.forEach((b, i) => { const [o, tb] = child(b); out.push(`if(${o}){${nc}++;${tc}=${tb}${fc ? `;${fc.count}++${fc.mask ? `;${fc.mask}|=${1 << i}` : ''}` : ''}}`) })
+      out.push(`if(${nc}===1)${raise(tc)}`)
+    }
+    if (schema.if !== undefined) {
+      const [oi, ti] = child(schema.if)
+      const thenPart = []
+      if (schema.then !== undefined) { const sv = out.length; const [ot, tt] = child(schema.then); thenPart.push(...out.splice(sv)); thenPart.push(`if(${ot})${raise(tt)}`) }
+      const elsePart = []
+      if (schema.else !== undefined) { const sv = out.length; const [oe, te] = child(schema.else); elsePart.push(...out.splice(sv)); elsePart.push(`if(${oe})${raise(te)}`) }
+      out.push(`if(${oi}){${raise(ti)};${thenPart.join(';')}}else{${elsePart.join(';')}}`)
+    }
+    if (typeof schema.$ref === 'string') { const [o, tb] = child(refTargetFor(schema.$ref, ctx)); out.push(`if(${o})${raise(tb)}`) }
+    const iv = `_ix${id}`
+    const ui2 = schema.unevaluatedItems
+    if (ui2 === false) {
+      // Reported once, at the first position left, as the interpreter does.
+      out.push(`if(${n}<${len}){const ${iv}=${n};${fail('unevaluatedItems', 'unevaluatedItems', `{limit:${iv}}`, `'must NOT have more than '+${iv}+' items'`)}}`)
+    } else if (typeof ui2 === 'object' && ui2 !== null) {
+      const pe = pathExpr ? `${pathExpr}+'/'+${iv}` : `'/'+${iv}`
+      const sub = []
+      genCodeC(ui2, `${v}[${iv}]`, pe, sub, ctx, schemaPrefix + '/unevaluatedItems')
+      if (sub.length) out.push(`for(let ${iv}=${n};${iv}<${len};${iv}++){${sub.join('\n  ')}\n  }`)
+    } else {
+      throw DECLINE
+    }
+    const text = out.join(';')
+    if (text.length > ANNOT_INLINE_MAX || /\b(?:_validate|_stk|_sd|_sg|_CYC)\b/.test(text)) { restoreCtx(ctx, saved); return null }
+    return text
+  } catch (e) {
+    if (e !== DECLINE) throw e
+    restoreCtx(ctx, saved)
+    return null
+  }
+}
+
 function genUnevaluatedItemsDynamicC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
   if (schema.$dynamicRef !== undefined || schema.$recursiveRef !== undefined) throw DECLINE
   if (Array.isArray(schema.items) || schema.additionalItems !== undefined) throw DECLINE
+  const inline = inlineUnevalItemsBlock(schema, v, pathExpr, ctx, schemaPrefix, fail)
+  if (inline !== null) { lines.push(`if(Array.isArray(${v})){${inline}}`); return }
   annItemHelpers(ctx)
   const ui = ctx.varCounter++
   const S = `_es${ui}`
@@ -7185,7 +8200,7 @@ function emitAnnotI(sub, ctx) {
   if (locals.length) body.push(`if(Array.isArray(d)){${locals.join(';')}}`)
   for (const b of sub.allOf || []) body.push(`if(!${emitAnnotI(b, ctx)}(d,${R}))${failOut}`)
   if (Array.isArray(sub.anyOf)) body.push(`{let _a=false;${sub.anyOf.map((b) => `if(${emitAnnotI(b, ctx)}(d,${R}))_a=true;`).join('')}if(!_a)${failOut}}`)
-  if (Array.isArray(sub.oneOf)) body.push(`{let _c=0;${sub.oneOf.map((b) => `if(${emitAnnotI(b, ctx)}(d,${R}))_c++;`).join('')}if(_c!==1)${failOut}}`)
+  if (Array.isArray(sub.oneOf)) body.push(`{let _c=0;${sub.oneOf.map((b) => `if(${emitAnnotI(b, ctx)}(d,${R})&&++_c>1)${failOut}`).join('')}if(_c!==1)${failOut}}`)
   if (sub.if !== undefined) {
     const thenCheck = sub.then !== undefined ? `if(!${emitAnnotI(sub.then, ctx)}(d,${R}))${failOut}` : ''
     const elseCheck = sub.else !== undefined ? `if(!${emitAnnotI(sub.else, ctx)}(d,${R}))${failOut}` : ''
@@ -7227,8 +8242,9 @@ function genUnevaluatedFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix, fai
     const checksU = propKeysU.map(k => `_k${ui}[_i]!==${JSON.stringify(k)}`).join('&&')
     innerU = `const _k${ui}=Object.keys(${v});for(let _i=0;_i<_k${ui}.length;_i++)if(${checksU}){${failU}}`
   } else {
-    const allowedU = propKeysU.map(k => JSON.stringify(k)).join(',')
-    innerU = `const _k${ui}=Object.keys(${v});const _a${ui}=new Set([${allowedU}]);for(let _i=0;_i<_k${ui}.length;_i++)if(!_a${ui}.has(_k${ui}[_i])){${failU}}`
+    ctx.closureVars.push(`_a${ui}`)
+    ctx.closureVals.push(new Set(propKeysU))
+    innerU = `const _k${ui}=Object.keys(${v});for(let _i=0;_i<_k${ui}.length;_i++)if(!_a${ui}.has(_k${ui}[_i])){${failU}}`
   }
   lines.push(isObj ? `{${innerU}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${innerU}}`)
 }
@@ -7630,5 +8646,7 @@ function _collectEval(schema, result, defs, schemaMap, refStack, isRoot) {
 }
 
 module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined, collectEvaluated, unevalContributions, expandedChars, AJV_MESSAGES, _setCodeBudget }
+// For tests: the dynamic-scope unrolling, to hold its output to the interpreter.
+Object.defineProperty(module.exports, '_expandDynamicScopes', { value: expandDynamicScopes, enumerable: false })
 // 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 })