ata-validator 1.36.1 → 1.37.0

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

@@ -1471,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 };
@@ -1612,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
@@ -1623,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.1';
+module.exports = '1.37.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.36.1",
+  "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.1",
-    "@ata-validator/native-darwin-x64": "1.36.1",
-    "@ata-validator/native-linux-arm64-gnu": "1.36.1",
-    "@ata-validator/native-linux-arm64-musl": "1.36.1",
-    "@ata-validator/native-linux-x64-gnu": "1.36.1",
-    "@ata-validator/native-linux-x64-musl": "1.36.1",
-    "@ata-validator/native-win32-x64": "1.36.1"
+    "@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 };