ata-validator 1.36.0 → 1.37.0

package/README.md

@@ -101,16 +101,15 @@ file.
 | Bundle (gzipped) | simple | 1.3 KB | 58.1 KB | 43.9x smaller |
 | Bundle (gzipped) | complex | 7.8 KB | 58.1 KB | 7.4x smaller |
 | Bundle (gzipped) | nested | 4.5 KB | 58.1 KB | 12.9x smaller |
-| Cold start | simple | 22 ms | 44 ms | 2.0x faster |
-| Throughput (1M ops) | simple | 266 Mops/s | 109 Mops/s | 2.4x faster |
-| Compile time | simple | 19 µs | 1.67 ms | 87x faster |
+| Cold start | simple | 22 ms | 40 ms | 1.8x faster |
+| Throughput (1M ops) | simple | 269 Mops/s | 116 Mops/s | 2.3x faster |
+| Compile time | simple | 19 µs | 1.63 ms | 85x faster |
 
 The runtime column is the default validator most frameworks ship. Reproduce on your machine
 with `npm run bench:aot-vs-ajv`. Numbers from one run on Apple M4 Pro, Node 25.2.1, 2026-09-28,
-on ata-validator 1.33.1. The runtime column's bundle measured 52.7 KB on the previous run and
-58.1 KB now, with ata's modules unchanged in size. Across three runs throughput moved
-between 231 and 280 Mops/s against 97 to 109, cold start between 21 and 22 ms against 40 to 44,
-and the compile ratio between 80x and 87x. The throughput row times a single one-million-call
+on ata-validator 1.36.0. Across four runs throughput moved between 213 and 269 Mops/s against
+94 to 116, cold start between 21 and 22 ms against 40 to 42, and the compile ratio between 79x
+and 90x. The throughput row times a single one-million-call
 loop of a few milliseconds, so it moves the most from run to run; treat the last three rows as
 an order of magnitude rather than a constant.
 
@@ -240,21 +239,21 @@ is the most common way to get a misleading number out of this library.
 
 | | compiled with `ata build` | runtime `new Validator(schema)` |
 |---|---|---|
-| In a bundle, gzipped | **2.2 KB** | 93.2 KB |
-| Time to a served request | **3.5 ms** | 7.7 ms |
+| In a bundle, gzipped | **2.2 KB** | 95.6 KB |
+| Time to a served request | **3.5 ms** | 7.8 ms |
 | Schema known when | build time | any time |
 
 The bundle row is the ten-field user schema in
 `tests/fixtures/error-dx/user.schema.json`, every export of the compiled module against
-`new Validator(schema)`, built with `bun build --minify --target=browser` on ata 1.35.0.
-The startup row is a Hono route on Bun 1.4, best of seven, median of three rounds, from
+`new Validator(schema)`, built with `bun build --minify --target=browser` on ata 1.36.0.
+The startup row is a Hono route on Bun 1.4, median of nine interleaved runs, from
 `benchmark/bundle`, against 3.5 ms for the same app doing no validation at all, so the
 compiled path costs nothing measurable to start. The runtime figure is what it is because
 a schema that arrives at run time can use any keyword, so the whole engine has to be
 there. The compiled module imports nothing and contains only the checks your schema asks
 for.
 
-**On a server, use whichever fits your schemas.** 93 KB of JavaScript on a Node or Bun
+**On a server, use whichever fits your schemas.** 96 KB of JavaScript on a Node or Bun
 process is not a cost anyone notices, and the runtime API is the simpler thing to reach
 for. Speed is the same either way once warm.
 
@@ -486,7 +485,7 @@ const v = new Validator(schema, {
 
 ### Build-time compile (`ata compile`)
 
-The `ata` CLI turns a JSON Schema file into a self-contained JavaScript module. No runtime dependency on `ata-validator`, so only the generated validator ships to the browser. For the ten-field user schema in `tests/fixtures/error-dx/user.schema.json` the module is 2.2 KB gzipped, full error detail included, against 93.2 KB for the runtime bundled for the browser.
+The `ata` CLI turns a JSON Schema file into a self-contained JavaScript module. No runtime dependency on `ata-validator`, so only the generated validator ships to the browser. For the ten-field user schema in `tests/fixtures/error-dx/user.schema.json` the module is 2.2 KB gzipped, full error detail included, against 95.6 KB for the runtime bundled for the browser.
 
 ```bash
 npx ata compile schemas/user.json -o src/generated/user.validator.mjs
@@ -528,11 +527,11 @@ npx ata build 'schemas/*.json' --out-dir build/validators --check
 Run with `--watch` during development for incremental rebuilds.
 
 Bundle sizes for the 10-field user schema in `tests/fixtures/error-dx/user.schema.json`,
-minified and gzipped, measured with `bun build --minify --target=browser` on ata 1.35.0:
+minified and gzipped, measured with `bun build --minify --target=browser` on ata 1.36.0:
 
 | What the app imports | Size | Notes |
 |---|---|---|
-| `Validator` from `ata-validator` | 93.2 KB | The compiler ships with it, because a runtime schema can use any keyword |
+| `Validator` from `ata-validator` | 95.6 KB | The compiler ships with it, because a runtime schema can use any keyword |
 | `isValid` from the compiled module | **1.3 KB** | Nothing else is reachable, so the error collector is dropped |
 | `validate` from the compiled module | **2.0 KB** | Adds the detailed error collector |
 
@@ -541,6 +540,16 @@ bundling it makes no difference: importing only `isValid` already leaves the err
 collector unreachable, and a bundler drops it. Use the flag to cut the file on disk,
 not to cut what ships.
 
+To get the compiled module without changing code written against the runtime API, use
+`compileAway` in [`@ata-project/unplugin`](https://github.com/ata-core/unplugin-ata): a
+`new Validator(schema)` whose schema is known at build time is replaced with the compiled
+module wrapped by `fromCompiled()` from `ata-validator/compiled`, which answers `validate()`,
+`isValidObject()`, `validateJSON()` and `isValidJSON()` as the runtime does, defaults and errors
+included. For the plugin's three-schema test entry a minified Vite build goes from 115.7 KB to
+15.5 KB gzipped. In Node, loading the wrapper and a compiled module and answering the first two
+checks takes 1.12 ms where the runtime takes 6.63 ms (median of 15 fresh processes). Across
+SchemaStore's 977 schemas, 725 can be compiled away; the rest stay on the runtime.
+
 Programmatic API if you prefer to script it:
 
 ```javascript
@@ -557,7 +566,7 @@ through a `setFormats()` export the module carries. `docs/API.md` has the
 details.
 
 **Fastify startup, 10 route schemas, from a cold process to the first validated request:
-ajv 20.2 ms, ata 2.7 ms, no build step required.** ata registers in 0.2 ms of that and
+ajv 19.9 ms, ata 2.9 ms, no build step required.** ata registers in 0.5 ms of that and
 compiles on the first request, so counting only registration would overstate the gap.
 Reproduce with `node benchmark/bench_fastify_boot.mjs`.
 

package/build.d.ts

@@ -178,3 +178,10 @@ export function compiledSchemaFor(schema: unknown): object;
  * whose detailed errors the generator cannot produce.
  */
 export function compiledModuleFor(schema: unknown, opts?: { format?: 'esm' | 'cjs' }): string | null;
+
+/**
+ * The Validator options `fromCompiled()` reproduces, so a plugin can tell
+ * whether `new Validator(schema, options)` can be replaced. Absent before
+ * ata-validator 1.37.0, where only calls without options can be.
+ */
+export const compiledOptions: readonly string[];

package/build.mjs

@@ -12,4 +12,5 @@ export const schemaHash = mod.schemaHash;
 export const compiledEligible = mod.compiledEligible;
 export const compiledSchemaFor = mod.compiledSchemaFor;
 export const compiledModuleFor = mod.compiledModuleFor;
+export const compiledOptions = mod.compiledOptions;
 export default mod;

package/compiled.d.ts

@@ -14,4 +14,12 @@ export interface CompiledValidator<T = unknown> {
   isValidJSON(json: string): boolean;
 }
 
-export function fromCompiled<T = unknown>(mod: CompiledModule, schema: object): CompiledValidator<T>;
+/** The Validator options `fromCompiled` reproduces. Any other option throws. */
+export const COMPILED_OPTIONS: readonly ['useDefaults'];
+
+export interface CompiledOptions {
+  /** `false` leaves the input unchanged, as `new Validator(schema, { useDefaults: false })` does. */
+  useDefaults?: boolean;
+}
+
+export function fromCompiled<T = unknown>(mod: CompiledModule, schema: object, options?: CompiledOptions): CompiledValidator<T>;

package/compiled.mjs

@@ -1,3 +1,3 @@
 import mod from './compiled.js';
-export const { fromCompiled } = mod;
+export const { fromCompiled, COMPILED_OPTIONS } = mod;
 export default mod;

package/index.d.ts

@@ -452,6 +452,17 @@ export interface BundleStandaloneOptions extends ValidatorOptions {
 export interface StandardSchemaV1Props<Output = unknown, Input = unknown> {
   version: 1;
   vendor: "ata-validator";
+  /**
+   * Standard JSON Schema: the schema this validator checks, as a copy, for a
+   * consumer that publishes it (the MCP SDK's `inputSchema`, for one). The
+   * target must be the dialect the schema declares, and a schema without
+   * `$schema` is 2020-12. Any other target throws; ata does not convert
+   * between dialects.
+   */
+  jsonSchema: {
+    input(options: { target: "draft-2020-12" | "draft-07" | (string & {}); libraryOptions?: Record<string, unknown> }): Record<string, unknown>;
+    output(options: { target: "draft-2020-12" | "draft-07" | (string & {}); libraryOptions?: Record<string, unknown> }): Record<string, unknown>;
+  };
   validate(
     value: unknown
   ):

package/lib/aot-build.js

@@ -295,8 +295,8 @@ const { schemaHash } = require('./schema-hash');
 // tests/test_compiled_parity.js holds that. Declined: custom error messages,
 // which the core applies in a layer the wrapper does not carry. A caller must also get a
 // module back from toStandaloneModule, which returns null for a schema it
-// cannot compile. The text checks are deliberately coarse: a property named
-// `default` declines too, and declining costs only the saving.
+// cannot compile. The text check is deliberately coarse: a property named
+// `errorMessage` declines too, and declining costs only the saving.
 function compiledEligible(schema) {
   if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) return false;
   return !JSON.stringify(schema).includes('"errorMessage"');
@@ -331,7 +331,13 @@ function compiledModuleFor(schema, opts) {
   return src && !degraded ? src : null;
 }
 
+// The Validator options fromCompiled() reproduces, for a plugin deciding whether
+// `new Validator(schema, options)` can be replaced. An older ata-validator does
+// not export this, and a plugin should then replace only calls without options.
+const { COMPILED_OPTIONS: compiledOptions } = require('./compiled');
+
 module.exports = {
+  compiledOptions,
   compiledEligible,
   compiledSchemaFor,
   compiledModuleFor,

package/lib/compiled.js

@@ -10,14 +10,20 @@
 //
 // Only for a schema compiledEligible() accepts, and with the schema
 // compiledSchemaFor() returns: the one the runtime reads, after normalization.
-// Custom error messages and every option other than the defaults stay on the
-// runtime. Defaults are applied as a default Validator applies them, before
-// any check, with the same code.
+// Custom error messages stay on the runtime, and so does every option except
+// the ones COMPILED_OPTIONS lists. Defaults are applied as a default Validator
+// applies them, before any check, with the same code; `useDefaults: false`
+// leaves the input as it is, as the runtime then does.
 
 const { LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy } = require('./rejections');
 const { buildDefaultsApplier } = require('./defaults');
 
 const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
+
+// The Validator options the wrapper answers the same way as the runtime.
+// Anything else changes what the runtime does in a way the wrapper does not
+// reproduce, so it is refused rather than ignored.
+const COMPILED_OPTIONS = Object.freeze(['useDefaults']);
 const EMPTY_ERRORS = Object.freeze([]);
 const VERDICT_DISAGREES = Object.freeze({
   valid: false,
@@ -43,9 +49,17 @@ class CompiledState {
   }
 }
 
-function fromCompiled(mod, schema) {
+function fromCompiled(mod, schema, options) {
+  if (options !== undefined && (options === null || typeof options !== 'object')) {
+    throw new TypeError('fromCompiled options must be an object');
+  }
+  for (const key of Object.keys(options || {})) {
+    if (!COMPILED_OPTIONS.includes(key)) {
+      throw new TypeError(`fromCompiled does not support the ${key} option; a Validator with it has to stay on the runtime`);
+    }
+  }
   const self = new CompiledState(schema);
-  const fill = buildDefaultsApplier(schema);
+  const fill = options && options.useDefaults === false ? null : buildDefaultsApplier(schema);
   if (fill) {
     self._mutatesInput = true;
     self._preprocess = fill;
@@ -93,4 +107,4 @@ function fromCompiled(mod, schema) {
   };
 }
 
-module.exports = { fromCompiled };
+module.exports = { fromCompiled, COMPILED_OPTIONS };

package/lib/js-compiler.js

@@ -1237,6 +1237,30 @@ const REF_NEUTRAL_SIBLINGS = new Set([
   'markdownEnumDescriptions', 'defaultSnippets', 'doNotSuggest', 'suggestSortText',
 ])
 
+// Stands for the schema path of a call to a recursive definition's error
+// helper while its body is generated; see genCodeENode. Not a pointer, so no
+// ordinal or source frame is looked up for it at compile time.
+const SP_PLACEHOLDER = '@@ata-sp@@'
+
+// Follows a definition that is a local $ref to another definition until it
+// reaches one that is not. False for a chain that loops, and for one whose
+// next hop is not a definition in this document; codegenSafe decides whether
+// a non-local reference resolves.
+function aliasChainEnds(def, defs) {
+  const seen = new Set()
+  let node = def
+  while (node && typeof node === 'object' && typeof node.$ref === 'string') {
+    const m = node.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)
+    if (!m) return !node.$ref.startsWith('#/')
+    const name = m[1].replace(/~1/g, '/').replace(/~0/g, '~')
+    if (seen.has(name)) return false
+    seen.add(name)
+    node = defs[name]
+    if (node === undefined) return false
+  }
+  return true
+}
+
 function codegenSafe(schema, schemaMap) {
   if (typeof schema === 'boolean') return true
   if (typeof schema !== 'object' || schema === null) return true
@@ -1381,7 +1405,11 @@ function codegenSafe(schema, schemaMap) {
         // codegen anchor maps register it (see "Build anchors map"), so anchor
         // refs (`$ref: '#name'`) resolve to it on all paths.
         if (def.$id && !def.$id.startsWith('#')) return false
-        if (def.$ref) return false // nested ref chain — bail
+        // A definition that is only a reference to another one is an alias,
+        // the shape TypeScript-to-schema generators emit for a named union.
+        // The generators resolve it like any other $ref; a chain of aliases
+        // that loops back on itself has no schema at its end and declines.
+        if (def.$ref && !aliasChainEnds(def, defs)) return false
         if (!codegenSafe(def, schemaMap)) return false
       }
     }
@@ -1697,7 +1725,103 @@ function sharedCodegenGate(schema, schemaMap) {
 
 // --- Codegen mode: generates a single Function (NOT CSP-safe) ---
 // This matches ajv's approach: one monolithic function, V8 JIT fully inlines it
+// `propertyNames` as the generators read it. They express maxLength,
+// minLength, pattern, const and enum, and the gate declines anything else, so
+// a schema that writes `propertyNames: { $ref: '#/definitions/Key' }` or adds
+// `type: 'string'` went to the interpreted engine. Both are rewritten here, on
+// a copy of the nodes that change: a local reference, through aliases, is
+// replaced by what it names, `type: 'string'` is dropped since every property
+// name is a string, and annotations go. Where what is left is still not all
+// supported keys, the node is left as written and the gate declines as before.
+// Errors keep the path the interpreted engine reports, which runs through the
+// reference without naming it.
+const PN_SUPPORTED = new Set(['maxLength', 'minLength', 'pattern', 'const', 'enum'])
+const PN_ANNOTATIONS = new Set(['$schema', '$comment', 'title', 'description', 'examples', 'default', 'deprecated', 'readOnly', 'writeOnly'])
+function simplePropertyNames(pn, defs) {
+  const seen = new Set()
+  while (pn && typeof pn === 'object' && typeof pn.$ref === 'string') {
+    if (Object.keys(pn).some((k) => k !== '$ref' && !PN_ANNOTATIONS.has(k) && !k.startsWith('x-'))) return null
+    const m = pn.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)
+    if (!m || !defs) return null
+    const name = m[1].replace(/~1/g, '/').replace(/~0/g, '~')
+    if (seen.has(name)) return null
+    seen.add(name)
+    pn = defs[name]
+  }
+  if (!pn || typeof pn !== 'object' || Array.isArray(pn)) return null
+  const out = {}
+  for (const [k, val] of Object.entries(pn)) {
+    if (PN_ANNOTATIONS.has(k) || k.startsWith('x-')) continue
+    if (k === 'type') {
+      if (val === 'string' || (Array.isArray(val) && val.includes('string'))) continue
+      return null
+    }
+    if (!PN_SUPPORTED.has(k)) return null
+    out[k] = val
+  }
+  return out
+}
+// The three generators are handed the same schema object for one validator,
+// so the rewrite is kept per object and done once. It walks the schema rather
+// than serializing it to look for the keyword: on a 7.6 MB schema the
+// serialization, three times over, was 3% of the first answer.
+const _pnNormalized = new WeakMap()
+function normalizePropertyNames(root) {
+  if (!root || typeof root !== 'object') return root
+  const hit = _pnNormalized.get(root)
+  if (hit !== undefined) return hit
+  const out = normalizePropertyNamesWalk(root)
+  _pnNormalized.set(root, out)
+  return out
+}
+function normalizePropertyNamesWalk(root) {
+  const defs = root.$defs || root.definitions || null
+  const seen = new Map()
+  const walk = (node) => {
+    if (node === null || typeof node !== 'object') return node
+    if (seen.has(node)) return seen.get(node)
+    seen.set(node, node)
+    if (Array.isArray(node)) {
+      let out = node
+      node.forEach((n, i) => { const w = walk(n); if (w !== n) { if (out === node) out = node.slice(); out[i] = w } })
+      seen.set(node, out)
+      return out
+    }
+    let out = node
+    const set = (k, v) => { if (out === node) out = { ...node }; out[k] = v }
+    for (const k of SUBSCHEMA_MAPS) {
+      const map = node[k]
+      if (!map || typeof map !== 'object') continue
+      let copy = map
+      for (const [name, sub] of Object.entries(map)) {
+        const w = walk(sub)
+        if (w !== sub) { if (copy === map) copy = { ...map }; copy[name] = w }
+      }
+      if (copy !== map) set(k, copy)
+    }
+    for (const k of SUBSCHEMA_LISTS) {
+      if (!Array.isArray(node[k])) continue
+      const w = walk(node[k])
+      if (w !== node[k]) set(k, w)
+    }
+    for (const k of SUBSCHEMA_SINGLES) {
+      if (k === 'propertyNames' || node[k] === null || typeof node[k] !== 'object') continue
+      const w = walk(node[k])
+      if (w !== node[k]) set(k, w)
+    }
+    if (node.propertyNames && typeof node.propertyNames === 'object') {
+      const simple = simplePropertyNames(node.propertyNames, defs)
+      if (simple && JSON.stringify(simple) !== JSON.stringify(node.propertyNames)) set('propertyNames', simple)
+    }
+    seen.set(node, out)
+    return out
+  }
+  return walk(root)
+}
+
 function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
+  const inputSchema = schema
+  schema = normalizePropertyNames(schema)
   if (typeof schema === 'boolean') return schema ? () => true : () => false
   if (typeof schema !== 'object' || schema === null) return null
   // removeAdditional: a verdict function that deletes the keys the remover
@@ -1768,7 +1892,7 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
   if (hasUnresolvableRef(schema, rootDefs, anchors, schemaMap, new Set())) return null
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
-  const ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: schema, userFormats: userFormats || null, removeNodes }
+  const ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: inputSchema, userFormats: userFormats || null, removeNodes }
   const lines = []
   try {
     genCode(schema, 'd', lines, ctx)
@@ -3912,6 +4036,8 @@ function genCharCodeSwitch(keys, v) {
 // Returns a function: (data, allErrors) => { valid, errors }
 // Valid path is still fast — only error path does extra work.
 function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts) {
+  const inputSchema = schema
+  schema = normalizePropertyNames(schema)
   // unevaluated* is generated only where it is provably its plain counterpart
   // (see unevalLocalOk); any occurrence that is not keeps the whole schema on
   // the interpreted engine's error path, exactly as before.
@@ -3974,7 +4100,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: schema, userFormats: userFormats || null,
+  const ctx = { varCounter: 0, helperCode: [], rootDefs: eRootDefs, shared: [], refStack: new Set(), schemaMap: schemaMap || null, anchors: eAnchors, 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: [],
@@ -4159,16 +4285,26 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         if (!fnName) {
           fnName = '_defE' + ctx.defFns.size + '_' + defName.replace(/[^A-Za-z0-9_]/g, '_')
           ctx.defFns.set(defName, fnName)
+          // The schema path comes in as an argument too, `_sp`, so an error
+          // names the path it was reached by, as it does when the definition
+          // is inlined and as the interpreted engine reports it; a fixed
+          // `#/$defs/<name>` named the definition instead. The body is
+          // generated against a placeholder prefix that becomes `_sp` in every
+          // string it starts. One left anywhere else declines, rather than
+          // emitting a path the placeholder stands in for.
           const bodyLines = []
-          genCodeE(ctx.rootDefs[defName], 'd', '_p', bodyLines, ctx, '#/$defs/' + defName)
+          genCodeE(ctx.rootDefs[defName], 'd', '_p', bodyLines, ctx, SP_PLACEHOLDER)
+          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){\n  ` +
-              `if(_sg){if(typeof d!=='object'||d===null)return ${fnName}_b(d,_p,_all,_e);if(${fnName}_s.has(d))return;${fnName}_s.add(d);try{return ${fnName}_b(d,_p,_all,_e)}finally{${fnName}_s.delete(d)}}\n  ` +
-              `if(++_sd>${CYCLE_DEPTH})throw _CYC\n  const _r=${fnName}_b(d,_p,_all,_e)\n  _sd--\n  return _r\n  }\n  ` +
-              `function ${fnName}_b(d,_p,_all,_e){${bodyLines.join('\n  ')}}`,
+            `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);if(!_all&&_e.length)return{valid:false,errors:_e}`)
+        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
@@ -4760,6 +4896,8 @@ function genIfE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 // Avoids double-pass (jsFn → false → errFn runs same checks again).
 // Uses type-aware optimizations: after type check passes, skip guards.
 function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
+  const inputSchema = schema
+  schema = normalizePropertyNames(schema)
   // Same provably-local rule as the error generator above.
   if (typeof schema === 'object' && schema !== null) {
     const s = JSON.stringify(schema)
@@ -4838,7 +4976,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
   const ctx = { varCounter: 0, helperCode: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
-                rootDefs: cRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: cAnchors, rootSchema: schema, userFormats: userFormats || null }
+                rootDefs: cRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: cAnchors, rootSchema: inputSchema, userFormats: userFormats || null }
   const lines = []
   try {
     genCodeC(schema, 'd', '', lines, ctx, '#')

package/lib/validator-core.js

@@ -218,7 +218,9 @@ function codegenAvailable() {
 // Schema compilation cache: same schema string -> reuse compiled functions
 const _compileCache = new Map();
 // Generated preprocess passes, keyed like _compileCache plus the options that
-// shape the pass. `null` records that the generator produced none.
+// shape the pass. Only passes that exist are kept: a schema with nothing to
+// rewrite answers `null` quickly, and keeping that answer held its key, the
+// whole schema text, for every such validator, 0.2 KB each.
 const _preprocessCache = new Map();
 
 // Object identity cache: same schema object reference -> reuse entire compiled state
@@ -908,7 +910,7 @@ class Validator {
       if (hit !== undefined) preprocess = hit;
       else {
         preprocess = _codegen.buildPreprocess(preprocessSchema, options) || null;
-        if (ppKey !== null) _preprocessCache.set(ppKey, preprocess);
+        if (ppKey !== null && preprocess !== null) _preprocessCache.set(ppKey, preprocess);
       }
     }
     if (!preprocess) {
@@ -1469,6 +1471,7 @@ class Validator {
       value: Object.freeze({
         version: 1,
         vendor: "ata-validator",
+        jsonSchema: standardJsonSchema(() => schemaObj),
         validate(value) {
           const result = v.validate(value);
           if (result.valid) return { value };
@@ -1610,6 +1613,31 @@ function defineSchema (schema) {
 // bound closure, stores it on the instance as an ordinary writable property
 // and returns it. The setter keeps the compile step's plain assignments
 // (`this.validate = fn`) working before the getter has ever run. Detached
+// Standard JSON Schema, the `jsonSchema` member of `~standard`: what a consumer
+// such as the MCP SDK reads to publish a schema, from `input({ target })`.
+// ata validates the JSON Schema it was given and does not transform values, so
+// input and output are the same document, handed back as a copy when the
+// target is the schema's dialect: draft-07 when it declares draft-07, 2020-12
+// when it declares 2020-12 or nothing, as ata reads it. Any other target
+// throws, as the specification asks, rather than returning a document that
+// would mean something else there.
+function standardJsonSchema(getSchema) {
+  const convert = (options) => {
+    const target = options && options.target;
+    const schema = getSchema();
+    if (schema === true) return {};
+    if (schema === false) return { not: {} };
+    const declared = typeof schema.$schema === 'string' ? schema.$schema : '';
+    const dialect = declared === '' || declared.includes('draft/2020-12/schema') ? 'draft-2020-12'
+      : declared.includes('draft-07/schema') ? 'draft-07' : declared;
+    if (target !== dialect) {
+      throw new TypeError(`ata-validator cannot provide a ${dialect} schema as ${String(target)}; it does not convert between dialects`);
+    }
+    return JSON.parse(JSON.stringify(schema));
+  };
+  return Object.freeze({ input: convert, output: convert });
+}
+
 // use (`const f = v.validate`) keeps working because the closure binds the
 // instance.
 // Standard Schema V1. Built on first read, then pinned to the instance with
@@ -1621,6 +1649,7 @@ Object.defineProperty(Validator.prototype, "~standard", {
     const std = Object.freeze({
       version: 1,
       vendor: "ata-validator",
+      jsonSchema: standardJsonSchema(() => self._rawSchema),
       validate(value) {
         const result = self.validate(value);
         if (result.valid) {

package/lib/version.js

@@ -7,4 +7,4 @@
 //
 // Kept in lockstep with package.json by `tests/test_version_sync.js`.
 
-module.exports = '1.36.0';
+module.exports = '1.37.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.36.0",
+  "version": "1.37.0",
   "description": "JSON Schema validation that compiles for speed and still runs where code generation is blocked. Compiled and interpreted engines answer identically at 100% of the official suite. TypeScript inference, Standard Schema V1, and a build step that emits dependency-free modules.",
   "main": "index.js",
   "module": "index.mjs",
@@ -59,7 +59,7 @@
     "release:check": "node scripts/regen-safe-regex-source.js && node tests/test_pack_purity.js && node scripts/check-doc-coverage.js && node tests/test_error_codes_lock.js && node tests/test_safe_regex_source_sync.js && node tests/test_version_sync.js",
     "build": "cmake-js build --target ata",
     "rebuild": "cmake-js rebuild --target ata",
-    "test": "node test.js && node tests/test_removed_aot_methods.js && node tests/test_no_native.js && node tests/test_no_eval.js && node tests/test_property_dependencies.js && node tests/test_v1_dialect.js && node tests/test_buffer_path_parity.js && node tests/test_text_path_errors.js && node tests/test_compiled_parity.js && node tests/test_buffer_gate.js && node tests/test_scanner_differential.js && node tests/test_validate_json_scanner_cost.js && node tests/test_buffer_reject_cost.js && node tests/test_nan_verdict.js && node tests/test_remove_additional_nested.js && node tests/test_exclusive_bounds.js && node tests/test_engine_differential.js && node tests/test_error_shape_differential.js && node tests/test_output_format.js && node tests/test_retry_message.js && node tests/test_describe_schema.js && node tests/test_aot_parse.js && node tests/test_draft7_semantics.js && node tests/test_metaschema_ref.js && node tests/test_pure_js_unsupported.js && node tests/test_native_load_order.js && node tests/test_pack_purity.js && node tests/test_make_native_package.js && node tests/test_browser_nofs.js && node tests/test_browser_imports_guard.js && node tests/test_esm_exports.js && node tests/test_version_sync.js && node tests/test_native_loaded.js && node tests/test_native_lazy.js && node tests/test_cold_start_modules.js && node tests/test_safe_regex_source_sync.js && node tests/test_t_builder.js && node tests/test_async_refine.js && node tests/test_safe_regex.js && node tests/test_safe_regex_integration.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_standalone_formats.js && node tests/test_aot_format_mode.js && node tests/test_aot_additional_props_errors.js && node tests/test_id_anchor_refs.js && node tests/test_engine_routing.js && node tests/test_engine_option.js && node tests/test_compile_cache_order.js && node tests/test_engine_diagnostic.js && node tests/test_format_engine_parity.js && node tests/test_error_accumulator_collision.js && node tests/test_uri_helper_parity.js && node tests/test_uri_fast_path.js && node tests/test_extend_verdict.js && node tests/test_ipv4_regex.js && node tests/test_ipv6_fast_path.js && node tests/test_nested_recursion_decline.js && node tests/test_generator_error_content.js && node tests/test_inherited_key_presence.js && node tests/test_proto_accessor.js && node tests/test_hybrid_tier.js && node tests/test_first_rejection_builds_one.js && node tests/test_container_local.js && node tests/test_one_shot_validate.js && node tests/test_fixed_pattern_inline.js && node tests/test_plan_source.js && node tests/test_fused_remove_additional.js && node tests/test_runtime_parse.js && node tests/test_formats_single_pass.js && node tests/test_email_format_cost.js && node tests/test_format_single_error.js && node tests/test_defs_pointer_alias.js && node tests/test_cross_doc_root_ref.js && node tests/test_codegen_entrypoint_agreement.js && node tests/test_ref_annotation_siblings.js && node tests/test_gate_wrapped_schemas.js && node tests/test_pattern_message_escape.js && node tests/test_nested_defaults_engines.js && node tests/test_nested_coercion_parity.js && node tests/test_preprocess_cache.js && node tests/test_large_schema_codegen.js && node tests/test_base_uri.js && node tests/test_hoisted_def_recursion.js && node tests/test_hybrid_agreement.js && node tests/test_codegen_edge_shapes.js && node tests/test_deferred_def_scope.js && node tests/test_node_scoped_ctx_flags.js && node tests/test_fast_slot_exhaustion.js && node tests/test_ajv_errors.js && node tests/test_custom_keywords.js && node tests/test_strict_schema.js && node tests/test_aot_external_checks.js && node tests/test_ajv_parity.js && node tests/test_user_format_error_path.js && node tests/test_unevaluated_error_path.js && node tests/test_unevaluated_error_shape.js && node tests/test_pattern_properties_errors.js && node tests/test_additional_properties_scaling.js && node tests/test_additional_props_combined_cost.js && node tests/test_no_input_mutation.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_error_code_lookup.js && node tests/test_error_order.js && node tests/test_error_order_ordinal.js && node tests/test_ref_error_order.js && node tests/test_rejection_shape.js && node tests/test_lazy_normalization.js && node tests/test_value_equality.js && node tests/test_vocabulary.js && node tests/test_schema_scan.js && node tests/test_lazy_errors.js && node tests/test_single_pass_errors.js && node tests/test_lazy_json_errors.js && node tests/test_lazy_instance.js && node tests/test_cyclic_input.js && node tests/test_native_error_codes.js && node tests/test_verdict_preprocess.js && node tests/test_lite_parity.js && node tests/test_lite_bundle_size.js && node tests/test_defaults_own_keys.js && node tests/test_plan_compiler.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_enrich_received.js && node tests/test_rich_errors_optout.js && node tests/test_error_messages.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_malformed_json_termination.js && node tests/test_data_positions.js && node tests/test_targeted_positions.js && node tests/test_position_map_cost.js && node tests/test_targeted_positions_cost.js && node tests/test_aot_staleness.js && node tests/test_file_positions.js && node tests/test_aot_positions_cost.js && node tests/test_schema_hash.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_additive_fields.js && node tests/test_diagnostic_source.js && node tests/test_diagnose.js && node tests/test_correlate.js && node tests/test_diagnostics_score.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node tests/test_cli_version.js && node benchmark/bench_aot_size.mjs",
+    "test": "node test.js && node tests/test_removed_aot_methods.js && node tests/test_no_native.js && node tests/test_no_eval.js && node tests/test_property_dependencies.js && node tests/test_v1_dialect.js && node tests/test_buffer_path_parity.js && node tests/test_text_path_errors.js && node tests/test_compiled_parity.js && node tests/test_buffer_gate.js && node tests/test_scanner_differential.js && node tests/test_validate_json_scanner_cost.js && node tests/test_buffer_reject_cost.js && node tests/test_nan_verdict.js && node tests/test_remove_additional_nested.js && node tests/test_exclusive_bounds.js && node tests/test_engine_differential.js && node tests/test_error_shape_differential.js && node tests/test_output_format.js && node tests/test_standard_json_schema.js && node tests/test_retry_message.js && node tests/test_describe_schema.js && node tests/test_aot_parse.js && node tests/test_draft7_semantics.js && node tests/test_metaschema_ref.js && node tests/test_pure_js_unsupported.js && node tests/test_native_load_order.js && node tests/test_pack_purity.js && node tests/test_make_native_package.js && node tests/test_browser_nofs.js && node tests/test_browser_imports_guard.js && node tests/test_esm_exports.js && node tests/test_version_sync.js && node tests/test_native_loaded.js && node tests/test_native_lazy.js && node tests/test_cold_start_modules.js && node tests/test_safe_regex_source_sync.js && node tests/test_t_builder.js && node tests/test_async_refine.js && node tests/test_safe_regex.js && node tests/test_safe_regex_integration.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_standalone_formats.js && node tests/test_aot_format_mode.js && node tests/test_aot_additional_props_errors.js && node tests/test_id_anchor_refs.js && node tests/test_engine_routing.js && node tests/test_engine_option.js && node tests/test_compile_cache_order.js && node tests/test_engine_diagnostic.js && node tests/test_format_engine_parity.js && node tests/test_error_accumulator_collision.js && node tests/test_uri_helper_parity.js && node tests/test_uri_fast_path.js && node tests/test_extend_verdict.js && node tests/test_ipv4_regex.js && node tests/test_ipv6_fast_path.js && node tests/test_nested_recursion_decline.js && node tests/test_generator_error_content.js && node tests/test_inherited_key_presence.js && node tests/test_proto_accessor.js && node tests/test_hybrid_tier.js && node tests/test_first_rejection_builds_one.js && node tests/test_container_local.js && node tests/test_one_shot_validate.js && node tests/test_fixed_pattern_inline.js && node tests/test_plan_source.js && node tests/test_fused_remove_additional.js && node tests/test_runtime_parse.js && node tests/test_formats_single_pass.js && node tests/test_email_format_cost.js && node tests/test_format_single_error.js && node tests/test_defs_pointer_alias.js && node tests/test_cross_doc_root_ref.js && node tests/test_codegen_entrypoint_agreement.js && node tests/test_ref_annotation_siblings.js && node tests/test_gate_wrapped_schemas.js && node tests/test_pattern_message_escape.js && node tests/test_nested_defaults_engines.js && node tests/test_nested_coercion_parity.js && node tests/test_preprocess_cache.js && node tests/test_large_schema_codegen.js && node tests/test_base_uri.js && node tests/test_hoisted_def_recursion.js && node tests/test_alias_definitions.js && node tests/test_property_names_ref.js && node tests/test_hybrid_agreement.js && node tests/test_codegen_edge_shapes.js && node tests/test_deferred_def_scope.js && node tests/test_node_scoped_ctx_flags.js && node tests/test_fast_slot_exhaustion.js && node tests/test_ajv_errors.js && node tests/test_custom_keywords.js && node tests/test_strict_schema.js && node tests/test_aot_external_checks.js && node tests/test_ajv_parity.js && node tests/test_user_format_error_path.js && node tests/test_unevaluated_error_path.js && node tests/test_unevaluated_error_shape.js && node tests/test_pattern_properties_errors.js && node tests/test_additional_properties_scaling.js && node tests/test_additional_props_combined_cost.js && node tests/test_no_input_mutation.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_error_code_lookup.js && node tests/test_error_order.js && node tests/test_error_order_ordinal.js && node tests/test_ref_error_order.js && node tests/test_rejection_shape.js && node tests/test_lazy_normalization.js && node tests/test_value_equality.js && node tests/test_vocabulary.js && node tests/test_schema_scan.js && node tests/test_lazy_errors.js && node tests/test_single_pass_errors.js && node tests/test_lazy_json_errors.js && node tests/test_lazy_instance.js && node tests/test_cyclic_input.js && node tests/test_native_error_codes.js && node tests/test_verdict_preprocess.js && node tests/test_lite_parity.js && node tests/test_lite_bundle_size.js && node tests/test_defaults_own_keys.js && node tests/test_plan_compiler.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_enrich_received.js && node tests/test_rich_errors_optout.js && node tests/test_error_messages.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_malformed_json_termination.js && node tests/test_data_positions.js && node tests/test_targeted_positions.js && node tests/test_position_map_cost.js && node tests/test_targeted_positions_cost.js && node tests/test_aot_staleness.js && node tests/test_file_positions.js && node tests/test_aot_positions_cost.js && node tests/test_schema_hash.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_additive_fields.js && node tests/test_diagnostic_source.js && node tests/test_diagnose.js && node tests/test_correlate.js && node tests/test_diagnostics_score.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node tests/test_cli_version.js && node benchmark/bench_aot_size.mjs",
     "bench:size": "node benchmark/bench_aot_size.mjs",
     "test:suite": "node tests/run_suite.js && node tests/run_suite.js draft7 && node tests/run_suite.js v1",
     "test:compat": "node tests/test_compat.js",
@@ -117,6 +117,7 @@
     "aot.mjs",
     "aot.d.ts",
     "lib/",
+    "!lib/plan-source.js",
     "compat.js",
     "compat.mjs",
     "compat.d.ts",
@@ -134,13 +135,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.36.0",
-    "@ata-validator/native-darwin-x64": "1.36.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.36.0",
-    "@ata-validator/native-linux-arm64-musl": "1.36.0",
-    "@ata-validator/native-linux-x64-gnu": "1.36.0",
-    "@ata-validator/native-linux-x64-musl": "1.36.0",
-    "@ata-validator/native-win32-x64": "1.36.0"
+    "@ata-validator/native-darwin-arm64": "1.37.0",
+    "@ata-validator/native-darwin-x64": "1.37.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.37.0",
+    "@ata-validator/native-linux-arm64-musl": "1.37.0",
+    "@ata-validator/native-linux-x64-gnu": "1.37.0",
+    "@ata-validator/native-linux-x64-musl": "1.37.0",
+    "@ata-validator/native-win32-x64": "1.37.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"

package/lib/plan-source.js

@@ -1,281 +0,0 @@
-'use strict';
-
-// Generated source from interpreter plans: the verdict function.
-//
-// The interpreted engine is the reference every other engine is tested
-// against, and its Plan is a schema node with every keyword resolved once.
-// lib/plan-compiler.js turns plans into closures; this turns them into source,
-// deciding at compile time exactly what plan-compiler decides, and calling the
-// same helpers (deepEqual, the code point bounds, multipleOfOk, the format
-// functions and compiled patterns the plan already holds), so the answers
-// cannot drift the way three hand-written generators did.
-//
-// The scope is deliberately narrow for now: value-level keywords, properties
-// and additionalProperties, prefixItems and items, and the in-place
-// applicators. Everything else, references, unevaluated*, contains,
-// propertyNames, patternProperties, dependentSchemas, custom keywords, makes
-// the compiler return null. It never emits a function with a keyword missing.
-
-const { createInterpreter, _planInternals: I } = require('./interpreter');
-const { Plan, deepEqual, cpAtLeast, cpAtMost, multipleOfOk, T_STRING, T_NUMBER, T_INTEGER, T_BOOLEAN, T_NULL, T_OBJECT, T_ARRAY } = I;
-
-const DECLINE = Symbol('plan-source.decline');
-const ALL_TYPES = T_STRING | T_NUMBER | T_INTEGER | T_BOOLEAN | T_NULL | T_OBJECT | T_ARRAY;
-
-// The own-property test the generators use; see ownKeyExpr in js-compiler.js.
-const HELPERS = 'const _hop=Object.prototype.hasOwnProperty;';
-
-const PROTO_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '__proto__']);
-
-function isPrimitive(x) {
-  return x === null || typeof x === 'string' || typeof x === 'boolean' || Number.isFinite(x);
-}
-
-function lit(x) {
-  return JSON.stringify(x);
-}
-
-function createCtx() {
-  return { n: 0, argNames: [], argVals: [], fns: [], fnFor: new Map() };
-}
-
-// A value the emitted code needs by reference: a function, a RegExp, a list.
-function arg(ctx, value) {
-  const i = ctx.argVals.indexOf(value);
-  if (i !== -1) return ctx.argNames[i];
-  const name = '_a' + ctx.argVals.length;
-  ctx.argNames.push(name);
-  ctx.argVals.push(value);
-  return name;
-}
-
-function local(ctx) {
-  return '_v' + ctx.n++;
-}
-
-// JSON Schema type bits, exactly as dataBits() assigns them: a non-finite
-// number has no type, so it matches neither number nor integer.
-function typeTest(mask, v) {
-  const parts = [];
-  if (mask & T_STRING) parts.push(`typeof ${v}==='string'`);
-  if (mask & T_NUMBER) parts.push(`Number.isFinite(${v})`);
-  else if (mask & T_INTEGER) parts.push(`Number.isInteger(${v})`);
-  if (mask & T_BOOLEAN) parts.push(`typeof ${v}==='boolean'`);
-  if (mask & T_NULL) parts.push(`${v}===null`);
-  if ((mask & T_OBJECT) && (mask & T_ARRAY)) parts.push(`(typeof ${v}==='object'&&${v}!==null)`);
-  else if (mask & T_OBJECT) parts.push(`(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`);
-  else if (mask & T_ARRAY) parts.push(`Array.isArray(${v})`);
-  return parts.length ? parts.join('||') : 'false';
-}
-
-// `plain` names a local holding `v.__proto__===Object.prototype`, read once per
-// object. With the key a constant at the `in`, the engine keeps the check
-// monomorphic; through a shared helper the key is a parameter and it is not.
-function ownTest(v, key, plain) {
-  const k = lit(key);
-  return PROTO_NAMES.has(key) ? `_hop.call(${v},${k})` : `(${plain}?${k} in ${v}:_hop.call(${v},${k}))`;
-}
-
-const K_NUM = T_NUMBER | T_INTEGER;
-// The body under a guard for one kind of value, given what the type check
-// already established: unconditional when the value can only be that kind,
-// nothing at all when it cannot be.
-function guarded(known, kind, cond, body) {
-  if (!body) return '';
-  if ((known & kind) === 0) return '';
-  if ((known & ~kind) === 0) return body;
-  return `if(${cond}){${body}}`;
-}
-
-// Value-level keywords, in compileLeafV's order and with its meaning.
-function emitLeaf(ctx, P, v, known) {
-  let out = '';
-  if (P.hasType) out += `if(!(${typeTest(P.typeMask, v)}))return false;`;
-  if (P.enum !== null) {
-    const vals = P.enum;
-    if (vals.length === 0) out += 'return false;';
-    else if (vals.every(isPrimitive)) out += `if(!(${vals.map((x) => `${v}===${lit(x)}`).join('||')}))return false;`;
-    else {
-      const a = arg(ctx, vals);
-      const de = arg(ctx, deepEqual);
-      const i = local(ctx);
-      out += `{let ${i}=0;for(;${i}<${a}.length;${i}++)if(${de}(${a}[${i}],${v}))break;if(${i}===${a}.length)return false}`;
-    }
-  }
-  if (P.hasConst) {
-    out += isPrimitive(P.const)
-      ? `if(${v}!==${lit(P.const)})return false;`
-      : `if(!${arg(ctx, deepEqual)}(${arg(ctx, P.const)},${v}))return false;`;
-  }
-  if (P.hasNumber) {
-    let n = '';
-    if (P.minimum !== undefined) n += `if(${v}<${lit(P.minimum)})return false;`;
-    if (P.maximum !== undefined) n += `if(${v}>${lit(P.maximum)})return false;`;
-    if (P.exclusiveMinimum !== undefined) n += `if(${v}<=${lit(P.exclusiveMinimum)})return false;`;
-    if (P.exclusiveMaximum !== undefined) n += `if(${v}>=${lit(P.exclusiveMaximum)})return false;`;
-    if (P.multipleOf !== undefined) n += `if(!${arg(ctx, multipleOfOk)}(${v},${lit(P.multipleOf)}))return false;`;
-    out += guarded(known, K_NUM, `Number.isFinite(${v})`, n);
-  }
-  if (P.hasString) {
-    let s = '';
-    if (P.minLength !== undefined) s += `if(!${arg(ctx, cpAtLeast)}(${v},${lit(P.minLength)}))return false;`;
-    if (P.maxLength !== undefined) s += `if(!${arg(ctx, cpAtMost)}(${v},${lit(P.maxLength)}))return false;`;
-    if (P.pattern !== null) s += `if(!${arg(ctx, P.pattern)}.test(${v}))return false;`;
-    if (P.formatFn !== null) s += `if(!${arg(ctx, P.formatFn)}(${v}))return false;`;
-    out += guarded(known, T_STRING, `typeof ${v}==='string'`, s);
-  }
-  if (P.minItems !== undefined || P.maxItems !== undefined || P.uniqueItems) {
-    let a = '';
-    if (P.minItems !== undefined) a += `if(${v}.length<${lit(P.minItems)})return false;`;
-    if (P.maxItems !== undefined) a += `if(${v}.length>${lit(P.maxItems)})return false;`;
-    if (P.uniqueItems) {
-      const de = arg(ctx, deepEqual);
-      const i = local(ctx), j = local(ctx);
-      a += `for(let ${i}=0;${i}<${v}.length;${i}++)for(let ${j}=${i}+1;${j}<${v}.length;${j}++)if(${de}(${v}[${i}],${v}[${j}]))return false;`;
-    }
-    out += guarded(known, T_ARRAY, `Array.isArray(${v})`, a);
-  }
-  return out;
-}
-
-// The object-level keywords of a node, value-level and structural together, so
-// the prototype of the object is read once for all of them.
-function emitObjectLeaf(ctx, P, v, plain) {
-  let o = '';
-  if (P.required !== null || P.minProperties !== undefined || P.maxProperties !== undefined || P.dependentRequired !== null) {
-    if (P.required !== null) for (const k of P.required) o += `if(!${ownTest(v, k, plain)})return false;`;
-    if (P.minProperties !== undefined) o += `if(Object.keys(${v}).length<${lit(P.minProperties)})return false;`;
-    if (P.maxProperties !== undefined) o += `if(Object.keys(${v}).length>${lit(P.maxProperties)})return false;`;
-    if (P.dependentRequired !== null) {
-      for (const [key, deps] of P.dependentRequired) {
-        o += `if(${ownTest(v, key, plain)}){${deps.map((dep) => `if(!${ownTest(v, dep, plain)})return false;`).join('')}}`;
-      }
-    }
-  }
-  return o;
-}
-
-// A subschema asked for a verdict of its own (a branch of anyOf/oneOf, the
-// subject of not/if) becomes a named function, emitted once per plan.
-function branchFn(ctx, node) {
-  if (node === true) return '_t';
-  if (node === false) return '_f';
-  let name = ctx.fnFor.get(node);
-  if (name !== undefined) return name;
-  name = '_b' + ctx.fnFor.size;
-  ctx.fnFor.set(node, name);
-  const body = emitNode(ctx, node, 'd');
-  ctx.fns.push(`function ${name}(d){${body}return true}`);
-  return name;
-}
-
-function emitNode(ctx, node, v) {
-  if (node === true) return '';
-  if (node === false) return 'return false;';
-  if (!(node instanceof Plan)) return '';
-  const P = node;
-  if (P.tracked || P.hasUnevaluated || P.hasCustom || P.macros !== null ||
-      P.contains !== undefined || P.propertyNames !== undefined || P.patternProperties !== null ||
-      P.dependentSchemas !== null || P.propertyDependencies !== null) {
-    throw DECLINE;
-  }
-  const known = P.hasType ? P.typeMask : ALL_TYPES;
-  let out = emitLeaf(ctx, P, v, known);
-
-  if (P.prefixItems !== null || P.items !== undefined) {
-    let a = '';
-    if (P.prefixItems !== null) {
-      P.prefixItems.forEach((child, i) => {
-        const x = local(ctx);
-        const body = emitNode(ctx, child, x);
-        if (body) a += `if(${v}.length>${i}){const ${x}=${v}[${i}];${body}}`;
-      });
-    }
-    if (P.items !== undefined) {
-      const start = P.prefixItems !== null ? P.prefixItems.length : 0;
-      const i = local(ctx);
-      const x = local(ctx);
-      const body = emitNode(ctx, P.items, x);
-      if (body) a += `for(let ${i}=${start};${i}<${v}.length;${i}++){const ${x}=${v}[${i}];${body}}`;
-    }
-    out += guarded(known, T_ARRAY, `Array.isArray(${v})`, a);
-  }
-
-  const plain = local(ctx);
-  let o = emitObjectLeaf(ctx, P, v, plain);
-  if (P.properties !== null || P.additionalProperties !== undefined) {
-    const declared = P.properties !== null ? [...P.properties.keys()] : [];
-    if (P.properties !== null) {
-      for (const [key, entry] of P.properties) {
-        const x = local(ctx);
-        const body = emitNode(ctx, entry.node, x);
-        if (body) o += `if(${ownTest(v, key, plain)}){const ${x}=${v}[${lit(key)}];${body}}`;
-      }
-    }
-    const ap = P.additionalProperties;
-    if (ap !== undefined && ap !== true) {
-      const k = local(ctx);
-      let isDeclared = 'false';
-      if (declared.length > 8) {
-        const set = Object.create(null);
-        for (const key of declared) set[key] = 1;
-        isDeclared = `${arg(ctx, set)}[${k}]===1`;
-      } else if (declared.length > 0) {
-        isDeclared = declared.map((key) => `${k}===${lit(key)}`).join('||');
-      }
-      let apBody;
-      if (ap === false) apBody = 'return false;';
-      else {
-        const x = local(ctx);
-        const body = emitNode(ctx, ap, x);
-        apBody = body ? `const ${x}=${v}[${k}];${body}` : '';
-      }
-      if (apBody) o += `for(const ${k} in ${v}){if(!${plain}&&!_hop.call(${v},${k}))continue;if(${isDeclared})continue;${apBody}}`;
-    }
-  }
-  if (o) out += guarded(known, T_OBJECT, `typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})`, `const ${plain}=${v}.__proto__===Object.prototype;${o}`);
-
-  if (P.allOf !== null) for (const child of P.allOf) out += emitNode(ctx, child, v);
-  if (P.anyOf !== null) out += `if(!(${P.anyOf.map((c) => `${branchFn(ctx, c)}(${v})`).join('||')}))return false;`;
-  if (P.oneOf !== null) {
-    const c = local(ctx);
-    out += `{let ${c}=0;${P.oneOf.map((b) => `if(${branchFn(ctx, b)}(${v})&&++${c}>1)return false;`).join('')}if(${c}!==1)return false}`;
-  }
-  if (P.not !== undefined) out += `if(${branchFn(ctx, P.not)}(${v}))return false;`;
-  if (P.if !== undefined) {
-    const t = P.then !== undefined ? emitNode(ctx, P.then, v) : '';
-    const e = P.else !== undefined ? emitNode(ctx, P.else, v) : '';
-    if (t || e) out += `if(${branchFn(ctx, P.if)}(${v})){${t}}else{${e}}`;
-  }
-  return out;
-}
-
-// Returns { fn, source } or null when the schema is outside what this emits.
-function compileVerdict(schema, options) {
-  let interp;
-  try {
-    interp = createInterpreter(schema, options || {});
-  } catch {
-    return null;
-  }
-  const ctx = createCtx();
-  let body;
-  try {
-    body = emitNode(ctx, interp.rootNode, 'd');
-  } catch (e) {
-    if (e === DECLINE) return null;
-    throw e;
-  }
-  const source = HELPERS + 'function _t(){return true}function _f(){return false}' +
-    ctx.fns.join('') + `return function(d){${body}return true}`;
-  let fn;
-  try {
-    // eslint-disable-next-line no-new-func
-    fn = new Function(...ctx.argNames, source)(...ctx.argVals);
-  } catch {
-    return null;
-  }
-  return { fn, source };
-}
-
-module.exports = { compileVerdict };