ata-validator 1.62.1 → 1.63.1

package/lib/ir/emit.mjs

@@ -0,0 +1,707 @@
+// IR backend: JavaScript source. It knows the IR operations
+// (README.md) and nothing about JSON Schema; a leaf kernel's check is written
+// from the kernel's own source (or a build-time fast path held to it).
+
+import { TYPES } from '../kernels/kernels.mjs'
+import { front, orderSkeleton, needsOrder } from './front.mjs'
+import * as KERNELS from '../kernels/index.mjs'
+
+// The names a module may import: exactly the exports of ata-validator/kernels.
+const KERNEL_NAMES = new Set(Object.keys(KERNELS))
+// The pattern unrolling of the code generator and the format hints of
+// lib/suggestions.js, as a generated copy (scripts/gen-ir-emit-deps.js), so
+// this file loads where neither the code generator nor the file system is.
+import { compilePatternInline, FORMAT_HINTS } from './emit-deps.mjs'
+const FAST = {
+  pattern: (n, x) => compilePatternInline(n, x),
+  // A string has between length/2 and length code points, so the length
+  // alone settles most cases and the count runs only near the bound.
+  minLength: (n, x) => `${x}.length>=${2 * n}||${x}.length>=${n}&&cpLen(${x})>=${n}`,
+  maxLength: (n, x) => `${x}.length<=${n}||${x}.length<=${2 * n}&&cpLen(${x})<=${n}`,
+}
+// enum and const with only primitive values need no deep equality: the
+// value is one of them exactly when it is === one of them (JSON numbers have
+// no NaN, and 0 and -0 are one value to JSON equality too).
+const prim = (v) => v === null || typeof v !== 'object'
+FAST.enum = (n, x) => Array.isArray(n) && n.every(prim) ? (n.length ? n.map((v) => `${x}===${JSON.stringify(v)}`).join('||') : 'false') : null
+FAST.const = (n, x) => prim(n) ? `${x}===${JSON.stringify(n)}` : null
+const GUARD = {
+  isStr: (x) => `typeof ${x}==="string"`,
+  isNum: (x) => `typeof ${x}==="number"`,
+  isArr: (x) => `Array.isArray(${x})`,
+  isObjV: (x) => `(typeof ${x}==="object"&&${x}!==null&&!Array.isArray(${x}))`,
+  isAny: () => 'true',
+}
+const lit = (v) => v === undefined ? 'void 0' : JSON.stringify(v)
+
+// The body of a one-expression arrow `(v, n) => body` or `(v) => body`, with
+// v and n replaced: the kernel's own source, specialized to the schema value.
+function inline (fn, vExpr, nExpr) {
+  const src = fn.toString()
+  const m = /^\(\s*v\s*(?:,\s*n\s*)?\)\s*=>\s*([\s\S]+)$/.exec(src)
+  if (!m) throw new Error('ir: kernel ok() must be (v, n) => expression: ' + src)
+  return '(' + m[1].replace(/\bv\b/g, vExpr).replace(/\bn\b/g, nExpr) + ')'
+}
+
+// How many names an object must list before a module visits the object's own
+// names instead of looking each one up. Measured on SchemaStore's samples,
+// warmed, against the compiled modules: from 16 names the geometric mean is
+// 0.878 with 23 schemas under half the time, from 32 it is 0.914 with 15,
+// from 64 0.941 with 8, and the count slower by a fifth is 47 at each. A
+// dense document under a short list (sil-kit, csslintrc: most of 16 to 38
+// names present) pays the walk's array and dispatch, 2 to 4x the direct
+// reads; a sparse one under a long list (putout, 475 names) would pay a
+// read per name, 100x the walk.
+const WALK_MIN = 16
+// Source characters past which a verdict body is its own function (the
+// verdict threshold of the current engine's generator, SPLIT_PROP_SCHEMA).
+const SPLIT_MIN = 2000
+// Entries a verdict's walk looks up in a table rather than a switch. A call
+// through the table is indirect, so V8 does not inline a small check behind
+// it: when most entries call a function of INLINE_MAX characters or fewer,
+// the switch's direct calls win below 64 entries (mocharc 650 to 229 ns,
+// huskyrc 290 to 149, targets about 90 characters). With larger targets
+// there is nothing to inline and the table stays from WALK_MIN entries
+// (abc-supply-plan, targets of 230 characters and more, 8-16% slower as a
+// switch).
+const TABLE_MIN = 64
+const INLINE_MAX = 160
+// A verdict that visits an object's names moves even small entries out when
+// they would add up past this many characters, and otherwise only the ones of
+// SPLIT_SMALL characters or more (the current engine's SPLIT_FN_BUDGET and
+// SPLIT_PROP_SMALL).
+const SPLIT_BUDGET = 24 * 1024
+const SPLIT_SMALL = 220
+
+export function emitIR (ir, { from = 'ata-validator/kernels', verdict = false, fill = null, richErrors = true } = {}) {
+  // richErrors false: the current engine's plain shape (keyword, instancePath,
+  // schemaPath, params, message), no enrichment, no related links.
+  const plain = richErrors === false
+  // Set when an object's names are visited in the object's order (`props`).
+  let WALKED = false
+  const uses = new Set(richErrors === false ? [] : ['E'])
+  const consts = []
+  const constOf = (src) => { const name = 'K' + consts.length; consts.push(`const ${name}=${src}`); return name }
+  const emitted = new Map()
+  const fns = []
+  const use = (...n) => { for (const x of n) if (x) uses.add(x) }
+  const ident = (src) => { for (const m of src.matchAll(/[A-Za-z_$][\w$]*/g)) use(m[0]); return src }
+
+  const hintFns = new Map()
+  const enumSets = new Map()
+  const knownFns = new Map()
+  // props nodes whose walk also rejects names properties does not list.
+  const folded = new WeakSet()
+  // Each emitted function's body size, for the choice between a switch of
+  // direct calls and a table (a procedure still being written has none).
+  const sizes = new Map()
+  // Imported from ata-validator/kernels (lib/kernels/formats.mjs, the same
+  // generated checks), so a page with several modules carries each once.
+  const formatFn = (name) => {
+    const fn = 'fmt_' + name.replace(/-/g, '_')
+    if (!KERNEL_NAMES.has(fn)) throw new Error(`ir emit: no generated check for format "${name}"`)
+    use(fn)
+    return fn
+  }
+  // An own-property test written in the module with the module's own
+  // reference to hasOwnProperty. The kernels' own() is one function for every
+  // module of a page, so its property lookup met the objects of every schema
+  // and stopped being cached for any (rc3-environment alone 1.0x the compiled
+  // module, beside 438 other schemas 2.1x).
+  let HOP = null
+  const ownSrc = (o, k) => {
+    if (HOP === null) HOP = constOf('Object.prototype.hasOwnProperty')
+    return `${HOP}.call(${o},${k})`
+  }
+  // A small verdict written in at its call, as the compiled modules write a
+  // referenced schema in at each property: every copy keeps its own record of
+  // the shapes it meets, where one function called from forty places met all
+  // of them and V8 stopped inlining it (coffeelint, 38 properties naming one
+  // definition). Only a verdict with no cycle through it, no guard and no
+  // dynamic scope, whose body is INLINE_BODY characters or fewer; a verdict
+  // body leaves only by `return false`, so it runs as a block. Its parameters
+  // are bound in the block: the value, and the empty paths and list of a
+  // verdict call.
+  const INLINE_BODY = 500
+  // Inlined source one function may take in all: past it a function grows
+  // beyond what V8 optimizes (putout's 475 properties, 0.01x the compiled
+  // module before, 1.08x with every call written in).
+  // 2000 left coffeelint's 38 names calling one 300-character check (2.2x
+  // the compiled module); 8000 inlines them and keeps putout's 475-name
+  // function optimizable (both measured on SchemaStore, warmed).
+  const INLINE_BUDGET = 8000
+  let inlineBudget = INLINE_BUDGET
+  const inlining = new Set()
+  const inlineBodies = new Map()
+  const inlineCall = (c) => {
+    if (c.proc === null || c.dynamic || c.guard || ir.dynamic || inlining.has(c.proc)) return null
+    const p = ir.procs.get(c.proc)
+    if (!p || p.mode !== 'verdict') return null
+    // Follow a verdict that is only a call of another (procName's alias).
+    const b = p.body.t === 'seq' && p.body.body.length === 1 ? p.body.body[0] : p.body
+    if (b.t === 'require' && b.e.t === 'pcall' && b.e.e === 'null' && !b.e.dynamic && !b.e.guard && b.e.x.t === 'var' && b.e.x.n === 'd' && b.e.proc !== c.proc) return inlineCall({ ...b.e, x: c.x })
+    // Each procedure is written once, with a full budget for what it
+    // inlines itself, and that text is its size: a site inlines it when the
+    // text fits the site's remaining budget. Written at every call site
+    // under the site's budget, the text depended on the order of the sites,
+    // and a definition too large under a deep nesting was rendered again
+    // for each site below each site (a suite schema took ten minutes).
+    let body = inlineBodies.get(c.proc)
+    if (body === undefined) {
+      inlining.add(c.proc); const saved = inlineBudget; inlineBudget = INLINE_BUDGET
+      try { body = stmt(p.body, true) } finally { inlining.delete(c.proc); inlineBudget = saved }
+      if (body.length > INLINE_BODY || /\breturn true\b/.test(body)) body = null
+      inlineBodies.set(c.proc, body)
+    }
+    if (body === null || body.length > inlineBudget) return null
+    inlineBudget -= body.length
+    const x = expr(c.x); const t = 'i' + (++inlineN)
+    return `{const ${t}=${x}\n{const d=${t},V=${t},e=null,P="",SP="",A=null\n${body}}}\n`
+  }
+  let inlineN = 0
+  // The verdict calls already made in the row of statements being written
+  // (seq), handed to a row nested directly in it.
+  let seqSeen = null
+  // The plain-prototype flags a fill has bound, by the object's expression.
+  const fillPlain = new Map()
+  const procName = (id) => {
+    if (emitted.has(id)) return emitted.get(id)
+    const p = ir.procs.get(id)
+    // A verdict that is one call of another on its own value (a branch that
+    // is only a $ref) is that other verdict: no function of its own, and a
+    // caller that already ran it can see the repeat (seq).
+    if (p.mode === 'verdict' && !ir.dynamic) {
+      const b = p.body.t === 'seq' && p.body.body.length === 1 ? p.body.body[0] : p.body
+      if (b.t === 'require' && b.e.t === 'pcall' && b.e.e === 'null' && !b.e.dynamic && !b.e.guard && b.e.x.t === 'var' && b.e.x.n === 'd' && b.e.proc !== id) {
+        const to = procName(b.e.proc)
+        emitted.set(id, to)
+        return to
+      }
+    }
+    const name = id
+    emitted.set(id, name)
+    const isVerdict = p.mode === 'verdict'
+    if (p.mode === 'fill') { fillPlain.clear(); fns.push(`function ${name}(d){\n${stmt(p.body, true)}}`); return name }
+    // Each function written gets its own budget of inlined source (inlineCall).
+    const savedBudget = inlineBudget
+    inlineBudget = INLINE_BUDGET
+    let body
+    try { body = stmt(p.body, isVerdict) } finally { inlineBudget = savedBudget }
+    const head = p.mode === 'ann' ? 'if(A===null)A=newAnn()\n' : ''
+    if (p.mode === 'ann') use('newAnn')
+    const wrapped = ir.dynamic
+      ? `const sv=SC;if(SC===null||SC.b!==${lit(p.base)})SC={b:${lit(p.base)},up:SC};try{\n${body}return true}finally{SC=sv}`
+      : `${body}return true`
+    fns.push(`function ${name}(d,e,s,P,V,SP,A){${head}${wrapped}}`)
+    sizes.set(name, wrapped.length)
+    return name
+  }
+
+  // A failure: `return false` in a verdict, a pushed error otherwise.
+  const fail = (er, v) => {
+    if (v) return 'return false'
+    if (plain) return `{if(e===null)return false;e.push({keyword:${lit(er.kw)},instancePath:${expr(er.path)},schemaPath:${expr(er.sp)},params:${expr(er.params)},message:${expr(er.msg)}})}`
+    let detail = 'void 0'; let suggest = 'void 0'
+    // A kernel function generated code names must have a name to import.
+    if ((er.detail && !er.detail.src) || (er.suggest && !er.suggest.src)) throw new Error(`ir emit: an unnamed enrichment function for ${er.kw}`)
+    if (er.detail) detail = ident(er.detail.src)
+    // A format's suggestion: only that format's hint, from the current
+    // engine's table (lib/suggestions.js FORMAT_HINTS), written in as source.
+    if (er.suggest && er.suggest.src === 'formatSuggest') {
+      const f = er.params.fields.find(([k]) => k === 'format')[1].v
+      const hint = FORMAT_HINTS[f]
+      suggest = hint ? (hintFns.get(f) || (hintFns.set(f, constOf(`(v)=>{const t=(${hint.toString()})(v);return t?{text:t,kind:"format"}:null}`)), hintFns.get(f))) : 'void 0'
+    } else if (er.suggest) suggest = /\(/.test(er.suggest.src) ? (ident(er.suggest.src), constOf(er.suggest.src)) : ident(er.suggest.src)
+    return `{if(e===null)return false;e.push(E(${lit(er.code)},${lit(er.kw)},${expr(er.path)},${expr(er.sp)},${expr(er.params)},${expr(er.msg)},${lit(er.exp)},${er.rank},${expr(er.ev)},s,${detail},${suggest}))}`
+  }
+
+  // A procedure call: its arguments, its target (a dynamic pick or fixed).
+  const callOf = (n, eArg, aArg) => {
+    if (n.proc === null) throw new Error('ir: a v1 $dynamicRef with no target of its own needs the closure backend')
+    const fn = procName(n.proc)
+    let target = fn
+    if (n.dynamic) { const table = constOf(`new Map([${n.dynamic.map(([b, id]) => `[${lit(b)},${procName(id)}]`).join(',')}])`); target = `pick(${table},${fn})` }
+    // A call that gathers no errors never reads its paths (custom keywords,
+    // the one reader that could, are refused by this writer): no strings to build.
+    const quiet = eArg === 'null'
+    // A call on a cycle (lib/ir/front.mjs `guard`): through a function that
+    // keeps the values this call is on and answers a second entry with no
+    // error, as the current engine cuts a reference it meets again.
+    if (n.guard) {
+      const G = constOf('new Set()'); const w = 'G' + fns.length
+      fns.push(`function ${w}(d,e,s,P,V,SP,A){if(${G}.has(d))return true\n${G}.add(d);try{return ${target}(d,e,s,P,V,SP,A)}finally{${G}.delete(d)}}`)
+      target = w
+    }
+    return `${target}(${expr(n.x)},${eArg},s,${n.path && !quiet ? expr(n.path) : '""'},${n.ev ? expr(n.ev) : expr(n.x)},${n.sp && !quiet ? expr(n.sp) : '""'},${aArg})`
+  }
+
+  // A verdict statement as a function of `name`, called the way a procedure
+  // is (value, e, s): it leaves only by `return false`.
+  const hoist = (node, name, text = stmt(node, true)) => {
+    const fn = 'L' + fns.length
+    fns.push(`function ${fn}(${name},e,s){\n${text}return true}`)
+    sizes.set(fn, text.length)
+    return fn
+  }
+
+  // Whether a statement reads no name but `name` and the ones it declares,
+  // and nothing of annotations (the caller's collector).
+  const selfContained = (n, name) => {
+    const bound = new Set([name]); const used = []; let ann = false
+    const walk = (x) => {
+      if (x === null || typeof x !== 'object') return
+      if (Array.isArray(x)) { for (const y of x) walk(y); return }
+      if (typeof x.t === 'string') {
+        if (x.t === 'var' || x.t === 'incr') used.push(x.n ?? x.name)
+        else if (x.t === 'let' || x.t === 'count') bound.add(x.name)
+        else if (x.t === 'keys') bound.add(x.k)
+        else if (x.t === 'range') bound.add(x.i)
+        else if (x.t === 'bind') for (const [k] of x.names) bound.add(k)
+        if (x.t.startsWith('ann') || x.t === 'firstUneval' || x.ann) ann = true
+      }
+      for (const k in x) if (k !== 'proc' && k !== 'K') walk(x[k])
+    }
+    walk(n)
+    return !ann && used.every((u) => bound.has(u))
+  }
+
+  // A keyed entry that reads its value and, when present, requires one
+  // procedure of it gathering nothing: the call, or null.
+  const verdictCall = (n) => {
+    if (n.t !== 'let' || n.body.t !== 'if' || n.body.else) return null
+    let b = n.body.then
+    while (b.t === 'seq' && b.body.length === 1) b = b.body[0]
+    if (b.t !== 'require') return null
+    const c = b.e
+    return c.t === 'pcall' && (c.e === 'null' || c.e === 'inherit') && !c.ann && !c.dynamic && c.x.t === 'var' && c.x.n === n.name ? c : null
+  }
+
+
+  // A default's value as source: a literal, a fresh empty array, or a copy.
+  const defaultSrc = (val) => {
+    if (typeof val !== 'object' || val === null) return lit(val)
+    if (Array.isArray(val) && val.length === 0) return '[]'
+    use('copyOf'); return `copyOf(${constOf(lit(val))})`
+  }
+
+  function stmt (n, v) {
+    switch (n.t) {
+      case 'seq': {
+        // A verdict that walks an object's names for its properties and has
+        // additionalProperties: false over the same object finds the unknown
+        // names in that walk: the separate pass over the object goes.
+        let skip = null
+        if (v) {
+          const walked = n.body.find((c) => c.t === 'if' && c.then.t === 'props' && c.then.closed && c.then.keyed !== null && c.then.keyed.length >= WALK_MIN && c.then.x.t === 'var')
+          const ap = walked && n.body.find((c) => c.t === 'if' && c.then.t === 'keys' && c.then.apClosed && c.then.obj.t === 'var' && c.then.obj.n === walked.then.x.n)
+          if (ap) { skip = ap; folded.add(walked.then) }
+        }
+        // In a verdict the same check of the same value twice in a row of
+        // statements is once: the first returned false or passed, and a
+        // verdict has no side effects (custom keywords and formats, which
+        // could, are refused above). A schema that names one definition
+        // under both allOf and anyOf ran it twice per item (devinit).
+        // A row nested directly in a row runs unconditionally after what came
+        // before it, so it shares the set; anything under a condition, a
+        // loop or a let starts its own.
+        const seen = v ? (seqSeen || new Set()) : null
+        seqSeen = null
+        return n.body.filter((x) => x !== skip).map((x) => {
+          seqSeen = x.t === 'seq' ? seen : null
+          const t = stmt(x, v)
+          seqSeen = null
+          if (seen !== null && (x.t === 'require' || x.t === 'branches')) { if (seen.has(t)) return ''; seen.add(t) }
+          return t
+        }).join('')
+      }
+      // An object that lists many names: visit the object's own names, every
+      // one enumerable or not (an entry checks its own presence, so a name it
+      // skips is one the object lacks), instead of looking each listed name
+      // up. Errors then come in the object's key order, so the module sorts
+      // them into schema order as the current engine does (WALKED).
+      case 'props': {
+        if (n.keyed === null || n.keyed.length < WALK_MIN) return n.body.map((x) => stmt(x, v)).join('')
+        WALKED = true
+        const keyed = new Set(n.keyed.map(([, i]) => i))
+        const always = n.body.filter((_, i) => !keyed.has(i)).map((x) => stmt(x, v)).join('')
+        // In a verdict, the entries that only call a procedure on their value
+        // go in a table by name: one lookup per key instead of a comparison
+        // per listed name. An entry whose checks read only its value can move
+        // into a function of its own and go in the table too: a large one
+        // always, a small one when the names together would make a function
+        // too large for V8 to optimize (a call costs more than a short check).
+        const X = expr(n.x)
+        const rows = n.keyed.map(([p, i]) => {
+          const e = n.body[i]
+          const c = v ? verdictCall(e) : null
+          if (c !== null) {
+            // A small check written in at its name (inlineCall), as the
+            // compiled modules write a referenced definition at each
+            // property: csslintrc's 31 names each called one enum check.
+            const t = inlineCall({ ...c, x: { t: 'var', n: 'y' } })
+            if (t !== null) return { p, inl: t }
+            return { p, fn: procName(c.proc) }
+          }
+          if (v && e.t === 'let' && e.body.t === 'if' && !e.body.else && selfContained(e.body.then, e.name)) {
+            const text = stmt(e.body.then, true)
+            return { p, e, text, src: `{const ${e.name}=${expr(e.value)}\nif(${expr(e.body.c)}){\n${text}}}\n` }
+          }
+          return { p, src: stmt(e, v) }
+        })
+        const big = rows.reduce((t, r) => t + (r.src ? r.src.length : 0), 0) > SPLIT_BUDGET
+        for (const r of rows) if (r.text !== undefined && (big || r.text.length >= SPLIT_SMALL)) r.fn = hoist(r.e.body.then, r.e.name, r.text)
+        const tabled = rows.filter((r) => r.fn)
+        const small = tabled.filter((r) => (sizes.get(r.fn) ?? Infinity) <= INLINE_MAX).length
+        const useTable = tabled.length >= TABLE_MIN || (tabled.length >= WALK_MIN && small * 2 < tabled.length)
+        const left = rows.filter((r) => !useTable || !r.fn)
+        // In the walk a name comes from the object's own names, so its value
+        // is read without a presence test.
+        const body = (r) => r.fn ? `{const y=${X}[${lit(r.p)}];if(y!==void 0&&!${r.fn}(y,null,s,"",y,"",null))return false}\n` : r.inl ? `{const y=${X}[${lit(r.p)}];if(y!==void 0){${r.inl}}}\n` : r.src
+        // A key is told from the names by its length first, a switch on an
+        // integer the engine makes a jump table, and then compared with the
+        // few names of that length: a switch on the names compared each key
+        // with half of them, which lost to a lookup per name once an object
+        // carried most of fifty (htmlhint).
+        const byLen = new Map()
+        for (const r of left) { const l = r.p.length; if (!byLen.has(l)) byLen.set(l, []); byLen.get(l).push(r) }
+        // Folded (see seq): every listed name has a case, a name without
+        // checks an empty one, and a name none of them is, own and
+        // enumerable, fails the verdict.
+        const fold = folded.has(n)
+        const unknown = fold ? `if(${constOf('Object.prototype.propertyIsEnumerable')}.call(${X},k))return false\n` : ''
+        if (fold) { const have = new Set(rows.map((r) => r.p)); for (const q of n.closed) if (!have.has(q)) { const l = q.length; if (!byLen.has(l)) byLen.set(l, []); byLen.get(l).push({ p: q, empty: true }) } }
+        const dispatch = (k) => `switch(${k}.length){\n${[...byLen].map(([l, rs]) => `case ${l}:${rs.map((r) => `if(${k}===${lit(r.p)}){\n${r.empty ? '' : body(r)}}`).join('else ')}${fold ? `else{${unknown}}` : ''}break\n`).join('')}${fold ? `default:${unknown}` : ''}}`
+        // A name the table answers is listed; with the fold every other name
+        // goes through the dispatch, which knows the listed ones.
+        let walk
+        if (!useTable) walk = `for(let j=0;j<ks.length;j++){const k=ks[j];${dispatch('k')}}`
+        else {
+          const T = constOf(`new Map([${tabled.map((r) => `[${lit(r.p)},${r.fn}]`).join(',')}])`)
+          walk = `for(let j=0;j<ks.length;j++){const k=ks[j],f=${T}.get(k);if(f!==void 0){const y=${X}[k];if(y!==void 0&&!f(y,null,s,"",y,"",null))return false}${left.length || fold ? `else ${dispatch('k')}` : ''}}`
+        }
+        // A self-measuring switch to a direct read of each listed name on
+        // dense documents was tried here and taken out: it won on five
+        // config schemas (csslintrc, coffeelint, jshintrc) and lost as much
+        // on others (liquibase 0.27 to 1.46 of the compiled module, a
+        // 142-name object read in dictionary mode 8x slower than the walk),
+        // no rule from the measurements told the two apart, and its direct
+        // form once rejected {} through an inherited toString.
+        return `${always}{const ks=Object.getOwnPropertyNames(${X});${walk}}\n`
+      }
+      case 'if': {
+        // A condition that is a call under annotations merges its collector.
+        if (n.c.t === 'pcall' && n.c.ann === 'merge') {
+          use('newAnn', 'mergeAnn')
+          return `{const a=newAnn();if(${callOf(n.c, 'null', 'a')}){mergeAnn(A,a)\n${stmt(n.then, v)}}else{\n${n.else ? stmt(n.else, v) : ''}}}\n`
+        }
+        return `if(${expr(n.c)}){\n${stmt(n.then, v)}}${n.else ? `else{\n${stmt(n.else, v)}}` : ''}\n`
+      }
+      case 'let': {
+        // A large verdict body becomes a function of its value: V8 does not
+        // optimize a function past its bytecode limit, and a schema inlined
+        // whole into one can pass it. A verdict body leaves only by `return
+        // false`, so the call keeps its meaning; what moves must read nothing
+        // of the enclosing function but the value. A presence test in front
+        // (it reads the parent) stays where it is.
+        const guarded = n.body.t === 'if' && !n.body.else && !(n.body.c.t === 'pcall' && n.body.c.ann === 'merge')
+        const inner = guarded ? n.body.then : n.body
+        const text = stmt(inner, v)
+        if (v && !ir.dynamic && text.length > SPLIT_MIN && selfContained(inner, n.name)) {
+          const call = `if(!${hoist(inner, n.name, text)}(${n.name},null,s))return false\n`
+          return `{const ${n.name}=${expr(n.value)}\n${guarded ? `if(${expr(n.body.c)}){\n${call}}\n` : call}}\n`
+        }
+        return `{const ${n.name}=${expr(n.value)}\n${guarded ? `if(${expr(n.body.c)}){\n${text}}\n` : text}}\n`
+      }
+      case 'bind': return `const ${n.names.map(([k, e]) => `${k}=${expr(e)}`).join(',')}\n`
+      case 'keys': {
+        if (n.order === 'forin') return `for(const ${n.k} in ${expr(n.obj)}){\n${stmt(n.body, v)}}\n`
+        // A verdict stops at the first failure whatever the order, so it
+        // needs no __proto__ moved last. (for-in with an own check, which
+        // allocates no array, made a schema alone up to 3x faster but 13 of
+        // SchemaStore's slower by 6-80% when all of them run in one process.)
+        const last = n.order === 'protoLast' && !v
+        if (last) use('keysOf')
+        // A verdict walks the object's own names with for-in, no array, each
+        // name tested as the object's own: a name enumerable on
+        // Object.prototype is not one of them (tests/test_ir_module_split.mjs).
+        if (v) {
+          const o = expr(n.obj)
+          return `for(const ${n.k} in ${o}){if(!${ownSrc(o, n.k)})continue\n${stmt(n.body, v)}}\n`
+        }
+        return `for(const ${n.k} of ${last ? 'keysOf' : 'Object.keys'}(${expr(n.obj)})){\n${stmt(n.body, v)}}\n`
+      }
+      case 'range': return `for(let ${n.i}=${typeof n.from === 'number' ? n.from : expr(n.from)};${n.i}<${expr(n.arr)}.length;${n.i}++){\n${stmt(n.body, v)}}\n`
+      case 'count': return `{let ${n.name}=0\n${stmt(n.body, v)}}\n`
+      case 'incr': return `${n.name}++\n`
+      case 'do': return `${expr(n.e)}\n`
+      case 'ret': return 'return false\n'
+      case 'require': {
+        const c = n.e
+        if (c.ann === 'merge') {
+          use('newAnn', 'mergeAnn')
+          return `{const a=newAnn(),c=e===null?0:e.length;if(${callOf(c, 'e', 'a')}&&(e===null||e.length===c))mergeAnn(A,a);else if(e===null)return false}\n`
+        }
+        if (v && c.e === 'null') { const t = inlineCall(c); if (t !== null) return t }
+        if (c.e === 'inherit') return v ? `if(!${callOf(c, 'null', 'null')})return false\n` : `if(!${callOf(c, 'e', 'null')}&&e===null)return false\n`
+        return `if(!${callOf(c, 'null', 'null')})${v ? 'return false' : '{if(e===null)return false}'}\n`
+      }
+      case 'fail': return fail(n.err, v) + '\n'
+      case 'branches': return branches(n, v)
+      case 'setDefault': {
+        if (n.k === '__proto__') use('setOwn')
+        const val = n.v
+        let src
+        if (typeof val !== 'object' || val === null) src = lit(val)
+        else if (Array.isArray(val) && val.length === 0) src = '[]'
+        else {
+          // A small default written as a literal: a fresh value each time
+          // it is read, as the compiled modules write `{}`. copyOf's JSON
+          // round trip was 72% of revola's verdict and 39% of changepacks'.
+          // Not when a key in it is `__proto__`, which a literal would read
+          // as the prototype, nor a large one, which would swell the fill.
+          const text = lit(val)
+          if (text.length <= 400 && !text.includes('"__proto__"')) src = text
+          else { use('copyOf'); src = `copyOf(${constOf(text)})` }
+        }
+        const o = expr(n.o)
+        // A store under the name itself: through setOwn's computed key, V8
+        // turned an object given more than a few defaults into a dictionary,
+        // slow from then on for every reader (htmlhint's root, 23 defaults:
+        // getOwnPropertyNames 10 to 999 ns). __proto__ needs defineProperty.
+        if (n.k === '__proto__') return `if(!${ownSrc(o, lit(n.k))})setOwn(${o},${lit(n.k)},${src})\n`
+        // A defined value under the name on an ordinary object is the
+        // object's own: the own test runs only for an undefined read, or on
+        // an object with another prototype, as the current engine's fill
+        // reads it. The flag is bound once per object in the fill.
+        if (!(n.k in Object.prototype)) {
+          let pl = fillPlain.get(o); let bind = ''
+          if (pl === undefined) { pl = 'pl' + fillPlain.size; fillPlain.set(o, pl); bind = `const ${pl}=(PN?${o}.__proto__:Object.getPrototypeOf(${o}))===Object.prototype\n` }
+          return `${bind}if((${o}[${lit(n.k)}]===void 0||!${pl})&&!${ownSrc(o, lit(n.k))})${o}[${lit(n.k)}]=${src}\n`
+        }
+        // A read or `in` before hasOwnProperty, as the current engine's fill
+        // does, was measured both ways: faster where the defaults are mostly
+        // present (jshintrc 1195 to 522 ns), slower where they are mostly
+        // missing (prometheus 3671 to 4601). hasOwnProperty alone is kept.
+        return `if(!${ownSrc(o, lit(n.k))})${o}[${lit(n.k)}]=${src}\n`
+      }
+      case 'fcall': return `${procName(n.proc)}(${expr(n.x)})\n`
+      case 'defaultsMask': {
+        // Bits in 32-bit words, set from the object's own names told apart by
+        // length and then by name; a default is written where its bit is clear.
+        const o = expr(n.o)
+        const words = Math.ceil(n.entries.length / 32)
+        const m = (i) => 'm' + Math.floor(i / 32)
+        const byLen = new Map()
+        n.entries.forEach(([k], i) => { if (!byLen.has(k.length)) byLen.set(k.length, []); byLen.get(k.length).push([k, i]) })
+        const cases = [...byLen].map(([l, ks]) => `case ${l}:${ks.map(([k, i]) => `if(k===${lit(k)})${m(i)}|=${(1 << (i % 32)) >>> 0}`).join(';else ')};break\n`).join('')
+        const sets = n.entries.map(([k, val], i) => `if((${m(i)}&${(1 << (i % 32)) >>> 0})===0)${o}[${lit(k)}]=${defaultSrc(val)}\n`).join('')
+        return `{let ${[...Array(words)].map((_, w) => 'm' + w + '=0').join(',')}\nconst ks=Object.getOwnPropertyNames(${o});for(let j=0;j<ks.length;j++){const k=ks[j];switch(k.length){\n${cases}}}\n${sets}}\n`
+      }
+      // The object's own names, each looked up in a table of the fills of
+      // the properties that have one (lib/ir/front.mjs fillProc).
+      case 'fillWalk': {
+        const o = expr(n.o)
+        const T = constOf(`new Map([${n.entries.map(([k, id]) => `[${lit(k)},${procName(id)}]`).join(',')}])`)
+        return `{const ks=Object.getOwnPropertyNames(${o});for(let j=0;j<ks.length;j++){const f=${T}.get(ks[j]);if(f!==void 0)f(${o}[ks[j]])}}\n`
+      }
+    }
+    throw new Error('ir emit: statement ' + n.t)
+  }
+
+  function branches (n, v) {
+    const isAny = n.kw === 'anyOf'
+    const ps = n.procs.map(procName)
+    // The calls that gather no errors get no paths (see callOf).
+    const x = expr(n.x); const path = expr(n.path); const ev = expr(n.ev); const sps = n.sps.map(expr)
+    if (v) {
+      const calls = ps.map((p) => `${p}(${x},null,s,"",${ev},"",null)`)
+      // One branch passes exactly when it passes, for anyOf and oneOf: the
+      // form of a required call, so a repeat of it is seen (seq).
+      if (calls.length === 1) return `if(!${calls[0]})return false\n`
+      return `if(${isAny ? `!(${calls.join('||')})` : `(${calls.map((c) => `(${c}?1:0)`).join('+')})!==1`})return false\n`
+    }
+    use('collapse')
+    const titles = constOf(lit(n.titles))
+    const tgt = n.ann === 'onlyIfOne' ? 'h' : 'A'
+    if (n.ann) use('newAnn', 'mergeAnn')
+    const vcalls = ps.map((p, i) => n.ann
+      ? `{const a=newAnn();if(${p}(${x},null,s,"",${ev},"",a)){c++;mergeAnn(${tgt},a)}}`
+      : `if(${p}(${x},null,s,"",${ev},"",null)){c++${isAny ? ';break b' : ''}}`).join('')
+    const ecalls = ps.map((p, i) => `(()=>{const be=[]${n.ann ? ',a=newAnn()' : ''};${p}(${x},be,s,${path},${ev},${sps[i]},${n.ann ? 'a' : 'null'});const ok=be.length===0;${n.ann ? `if(ok)mergeAnn(${tgt},a);` : ''}return{valid:ok,errors:be}})()`).join(',')
+    const sp = expr(n.sp)
+    // An anyOf with no annotations runs each branch once, filling a list of
+    // its own, and stops at the first that passes: no branch runs twice,
+    // whether the keyword passes or fails.
+    if (isAny && !n.ann) {
+      const tries = ps.map((p, i) => `{const be=[];${p}(${x},be,s,${path},${ev},${sps[i]},null);if(be.length===0){ok=true;break b}br.push({valid:false,errors:be})}`).join('')
+      return `if(e===null){let c=0;b:{${vcalls}}if(c===0)return false}else{let ok=false;const br=[];b:{${tries}}if(!ok){const r=collapse(${lit(n.kw)},br,${path},${sp},null,${titles});if(r!==null)e.push(${plain ? 'r' : `E(r.code,${lit(n.kw)},${path},${sp},r.params,r.message,void 0,${n.rank},${ev},s,void 0,void 0,r.branchErrors)`})}}\n`
+    }
+    // Otherwise the verdict first, with or without a list to fill: the branches' errors
+    // are built only when the keyword fails (collapse answers null exactly
+    // when it passes). Building them for a passing anyOf under propertyNames
+    // made a 257-key object 24x slower than the current engine. A failing
+    // run calls the branches again, merging the same annotations twice,
+    // which changes nothing.
+    return `{${n.ann === 'onlyIfOne' ? 'const h=newAnn();' : ''}let c=0;b:{${vcalls}}if(${isAny ? 'c!==0' : 'c===1'}){${n.ann === 'onlyIfOne' ? 'mergeAnn(A,h)' : ''}}else if(e===null)return false;else{const r=collapse(${lit(n.kw)},[${ecalls}],${path},${sp},null,${titles});if(r!==null)e.push(${plain ? 'r' : `E(r.code,${lit(n.kw)},${path},${sp},r.params,r.message,void 0,${n.rank},${ev},s,void 0,void 0,r.branchErrors)`})}}\n`
+  }
+
+  function pvExpr (n) {
+    const pv = n.pv
+    if (pv instanceof RegExp) return constOf(`new RegExp(${lit(pv.source)},${lit(pv.flags)})`)
+    if (typeof pv === 'function') { use(pv.name); return pv.name }
+    if (typeof pv === 'object' && pv !== null) return constOf(lit(pv))
+    return lit(pv)
+  }
+
+  function expr (n) {
+    switch (n.t) {
+      case 'lit': return lit(n.v)
+      case 'var': return n.n
+      case 'get': return `${expr(n.o)}[${expr(n.k)}]`
+      case 'field': return `${expr(n.o)}.${n.k}`
+      case 'own': return ownSrc(expr(n.o), expr(n.k))
+      case 'not': return `!(${expr(n.e)})`
+      case 'and': return `(${expr(n.a)}&&${expr(n.b)})`
+      case 'or': return `(${expr(n.a)}||${expr(n.b)})`
+      case 'cmp': return `${expr(n.a)}${n.op}${expr(n.b)}`
+      case 'isObj': use('isObj'); return `isObj(${expr(n.x)})`
+      case 'isArr': return `Array.isArray(${expr(n.x)})`
+      case 'isObjAny': { const x = expr(n.x); return `(typeof ${x}==="object"&&${x}!==null)` }
+      case 'len': return `${expr(n.x)}.length`
+      case 'plainProto': { const x = expr(n.x); return `(PN?${x}.__proto__:Object.getPrototypeOf(${x}))===Object.prototype` }
+      case 'type': {
+        const x = expr(n.x)
+        if (n.types.length === 1 && TYPES[n.types[0]]) return inline(TYPES[n.types[0]], x)
+        // A union over a variable: each type's own predicate, joined, as
+        // isTypes would try them; the table stays out of the module.
+        if (/^[A-Za-z_$][\w$]*$/.test(x) && n.types.every((t) => TYPES[t])) return `(${n.types.map((t) => inline(TYPES[t], x)).join('||')})`
+        use('isTypes'); return `isTypes(${x},${lit(n.types)})`
+      }
+      case 'guard': return GUARD[n.g](expr(n.x))
+      case 'kernel': {
+        const x = expr(n.x)
+        if (n.kw === 'format') return `${formatFn(n.n)}(${x})`
+        // 64 or more strings: a Set, one lookup instead of a chain that
+        // grows with the list (the threshold and its measurements are
+        // ENUM_SET_MIN in lib/js-compiler.js).
+        if (n.kw === 'enum' && Array.isArray(n.n) && n.n.length >= 64 && n.n.every((v) => typeof v === 'string')) {
+          const key = JSON.stringify(n.n)
+          if (!enumSets.has(key)) enumSets.set(key, constOf(`new Set(${key})`))
+          return `${enumSets.get(key)}.has(${x})`
+        }
+        const fast = FAST[n.kw] ? FAST[n.kw](n.n, x) : null
+        const src = fast ? `(${fast})` : inline(n.K.ok, x, pvExpr(n))
+        for (const id of ['cpLen', 'deq']) if (src.includes(id + '(')) use(id)
+        return src
+      }
+      case 'kfail': use(n.K.fail.name); return `${n.K.fail.name}(${expr(n.x)},${pvExpr(n)})`
+      case 'known': {
+        const k = expr(n.k)
+        // More than eight names: told apart by length first, a switch the
+        // engine makes a jump table, then compared with the few of that
+        // length, unless one length holds many (then a Set).
+        let names
+        if (n.names.length <= 8) names = n.names.map((q) => `${k}===${lit(q)}`)
+        else {
+          const byLen = new Map()
+          for (const q of n.names) { if (!byLen.has(q.length)) byLen.set(q.length, []); byLen.get(q.length).push(q) }
+          if (Math.max(...[...byLen.values()].map((a) => a.length)) <= 6) {
+            const key = JSON.stringify(n.names)
+            if (!knownFns.has(key)) knownFns.set(key, constOf(`(k)=>{switch(k.length){${[...byLen].map(([l, qs]) => `case ${l}:return ${qs.map((q) => `k===${lit(q)}`).join('||')}`).join(';')}}return false}`))
+            names = [`${knownFns.get(key)}(${k})`]
+          } else names = [`${constOf(`new Set(${lit(n.names)})`)}.has(${k})`]
+        }
+        const pats = n.pats.map((p) => `${constOf(`new RegExp(${lit(p)},"u")`)}.test(${k})`)
+        const all = [...names, ...pats]
+        return all.length ? `(${all.join('||')})` : 'false'
+      }
+      case 're': return `${constOf(`new RegExp(${lit(n.src)},"u")`)}.test(${expr(n.k)})`
+      case 'seg': use('seg'); return `seg(${expr(n.k)})`
+      case 'cat': return `${expr(n.a)}+${expr(n.b)}`
+      case 'str': return n.parts.map(expr).join('+')
+      case 'obj': return `{${n.fields.map(([k, v]) => `${JSON.stringify(k)}:${expr(v)}`).join(',')}}`
+      case 'annKey': return `(A.p===null?A.p=new Set():A.p).add(${expr(n.k)})`
+      case 'annHasKey': return `(A.p!==null&&A.p.has(${expr(n.k)}))`
+      case 'annPrefix': return `A.n=Math.max(A.n,Math.min(${n.n},${expr(n.arr)}.length))`
+      case 'annAll': return 'A.all=true'
+      case 'annAllSet': return 'A.all'
+      case 'annAt': return `(A.at===null?A.at=new Set():A.at).add(${expr(n.i)})`
+      case 'annAtHas': return `(A.at!==null&&A.at.has(${expr(n.i)}))`
+      case 'annN': return 'A.n'
+      case 'firstUneval': use('firstUneval'); return `firstUneval(A,${expr(n.x)})`
+      case 'pcall': return callOf(n, n.e === 'inherit' ? 'e' : 'null', 'null')
+    }
+    throw new Error('ir emit: expression ' + n.t)
+  }
+
+  const fillName = fill ? procName(fill) : null
+  const pre = fillName ? `${fillName}(d);` : ''
+  const dual = procName(ir.dual)
+  const ver = verdict ? procName(ir.verdict) : null
+  if (ir.relate && !plain) use('relate')
+  const sorts = WALKED || needsOrder(ir.schema)
+  if (sorts) use('ordered')
+  const names = [...uses].filter((u) => KERNEL_NAMES.has(u)).sort()
+  const imports = names.length ? `import {${names.join(',')}} from ${JSON.stringify(from)}` : ''
+  return `${imports}
+const PN=({}).__proto__===Object.prototype
+${ir.dynamic ? `let SC=null
+function pick(T,f){const a=[];for(let c=SC;c!==null;c=c.up)a.push(c.b);for(let i=a.length-1;i>=0;i--){const g=T.get(a[i]);if(g!==undefined)return g}return f}` : ''}
+${consts.join('\n')}
+${fns.join('\n')}
+const NONE=Object.freeze([])
+${sorts ? `const SK=JSON.parse(${JSON.stringify(JSON.stringify(orderSkeleton(ir.schema)))})\n` : ''}export function isValid(d){${pre}return ${ver || dual}(d,null,true,"",d,"#",null)}
+export function validate(d){${pre}if(${ver || dual}(d,null,true,"",d,"#",null))return{valid:true,data:d,errors:NONE};const e=[];${dual}(d,e,!(!d&&d!==0&&d!==false),"",d,"#",null);const o=${sorts ? 'ordered(SK,e)' : 'e'};return{valid:false,errors:${ir.relate && !plain ? 'o.length>1?relate(o):o' : 'o'}}}
+`
+}
+
+export function specialize (schema, opts = {}) {
+  // A module cannot carry the caller's functions.
+  if (opts.formats && Object.values(opts.formats).some((f) => typeof f === 'function')) throw new Error('ir: custom formats need the closure backend')
+  if (opts.keywords && Object.keys(opts.keywords).length) throw new Error('ir: custom keywords need the closure backend')
+  // Options that change the document or the shape of the answer: a module
+  // does not apply them, so it refuses them rather than answer without them.
+  for (const k of ['coerceTypes', 'removeAdditional', 'verbose', 'abortEarly']) if (opts[k]) throw new Error(`ir: ${k} needs the closure backend`)
+  const ir = front(schema, { assertFormat: opts.assertFormat !== false, schemas: opts.schemas || null, metaschemas: opts.metaschemas || null, baseURI: opts.baseURI || null })
+  const wantFill = opts.useDefaults !== false && hasDefault(schema)
+  // The specialized fill from the IR; the shared pass where it declined.
+  const src = emitIR(ir, { ...opts, fill: wantFill && ir.fill && ir.fill !== 'generic' ? ir.fill : null })
+  if (!wantFill || ir.fill !== 'generic') return src
+  // Where the IR declines the fill, the caller may hand the runtime's
+  // generated pass as source (`fillSource`, ata-validator/build's
+  // defaultsSource): written into the module as a function, the same pass the
+  // runtime and the previous compiled modules run. The interpreted shared pass
+  // took 780 of codeclimate's 855 ns.
+  // Not with other documents registered: the pass is built from this schema
+  // alone and would not follow a reference into them.
+  const own = typeof opts.fillSource === 'function' && !opts.schemas ? opts.fillSource(schema) : null
+  if (typeof own === 'string') {
+    return src
+      .replace('export function isValid(d){return ', `function FILL(d){\n${own}\n}\nexport function isValid(d){FILL(d);return `)
+      .replace('export function validate(d){', 'export function validate(d){FILL(d);')
+  }
+  // The shared default pass (lib/defaults.js), built from the normalized
+  // schema at load.
+  return src
+    .replace(/^import \{([^}]*)\} from /m, (m, list) => `import {${['buildDefaultsApplier', ...list.split(',')].filter(Boolean).sort().join(',')}} from `)
+    .replace('export function isValid(d){return ', `const FILL=buildDefaultsApplier(${JSON.stringify(ir.schema)})\nexport function isValid(d){FILL(d);return `)
+    .replace('export function validate(d){', 'export function validate(d){FILL(d);')
+}
+
+function hasDefault (s) {
+  if (typeof s !== 'object' || s === null) return false
+  if (Array.isArray(s)) return s.some(hasDefault)
+  if ('default' in s) return true
+  for (const k in s) if (hasDefault(s[k])) return true
+  return false
+}
+
+// A module's text as the body of a function that takes the kernels object and
+// returns { isValid, validate }: for a page that may evaluate code but loads
+// no module from a string. The text is this file's own output, in which every
+// value from the schema is written by JSON.stringify.
+export function functionBody (src) {
+  const m = /^import \{([^}]*)\} from "[^"\n]*"\n/.exec(src)
+  const head = m ? `const {${m[1]}}=K\n` : ''
+  return head + (m ? src.slice(m[0].length) : src).replace(/^export function /gm, 'function ') + 'return{isValid,validate}\n'
+}