ata-validator 1.31.2 → 1.31.3

package/index.js

@@ -244,26 +244,36 @@ function collectRemovals(schema, actions, path) {
 // Emit the in-place strip for one schema node and everything under its
 // `properties`. Scope matches collectRemovals(): object properties only, so
 // the two paths keep the same answer.
+// Each level's code, its own removal loop and its children's, sits inside the
+// guard for that level. A child used to be guarded only on itself, so its
+// access expression read through a parent that could be absent or null:
+// `{ c: { properties: { d: { additionalProperties: false } } } }` threw a
+// TypeError from validate({}) whenever the optional `c` was missing.
 function emitRemovals(node, access, lines, depth, seen) {
   if (!node || typeof node !== 'object' || !node.properties) return;
   if (seen.has(node)) return;
   seen.add(node);
   const keys = Object.keys(node.properties);
-  if (node.additionalProperties === false && keys.length > 0) {
+  const body = [];
+  // With no declared property every key is additional, as the interpreted
+  // engine's remover has it; this pass used to skip such a node entirely.
+  if (node.additionalProperties === false) {
     const kv = '_k' + depth;
     const checks = keys.map((k) => `${kv}!==${JSON.stringify(k)}`).join('&&');
-    const guard = depth === 0
-      ? ''
-      : `if(${access}!==null&&typeof ${access}==='object'&&!Array.isArray(${access}))`;
-    lines.push(`${guard}for(var ${kv} in ${access})if(${checks})delete ${access}[${kv}]`);
+    body.push(keys.length > 0
+      ? `for(var ${kv} in ${access})if(${checks})delete ${access}[${kv}]`
+      : `for(var ${kv} in ${access})delete ${access}[${kv}]`);
   }
   for (const key of keys) {
     const prop = node.properties[key];
     if (prop && typeof prop === 'object' && prop.properties) {
-      emitRemovals(prop, `${access}[${JSON.stringify(key)}]`, lines, depth + 1, seen);
+      emitRemovals(prop, `${access}[${JSON.stringify(key)}]`, body, depth + 1, seen);
     }
   }
   seen.delete(node);
+  if (body.length === 0) return;
+  if (depth === 0) lines.push(...body);
+  else lines.push(`if(${access}!==null&&typeof ${access}==='object'&&!Array.isArray(${access})){${body.join('\n')}}`);
 }
 
 // Generate a fast preprocess function via codegen instead of closure arrays
@@ -1306,6 +1316,23 @@ class Validator {
     this._mutatesInput = !!(preprocess || options.coerceTypes || options.removeAdditional);
     this._preprocess = preprocess;
 
+    // removeAdditional alone, the common parse-and-strip use: a verdict function
+    // that deletes unknown keys in the walk it already makes, where the pass
+    // above walks every object a second time just to find them. It answers
+    // the documents it accepts; anything it rejects takes the full path below,
+    // which removes, validates and reports exactly as before, so a rejected
+    // document is left as clean as it always was. The generator declines any
+    // schema where deleting during the walk could change an answer.
+    let fusedRemove = null;
+    if (preprocess && options.removeAdditional && !options.coerceTypes && !this._interpretOnly &&
+        !this._userFormats && !this._usesKeywords && !this._schemaStr.includes('"default"')) {
+      try {
+        fusedRemove = compileToJSCodegen(schemaObj, this._schemaMap.size > 0 ? this._schemaMap : null, null, { removeAdditional: true });
+      } catch {
+        fusedRemove = null;
+      }
+    }
+
     // Detect if schema is "selective" -- doesn't recurse into arrays/deep objects.
     const hasArrayTraversal =
       schemaObj &&
@@ -1577,9 +1604,11 @@ class Validator {
       // The verdict methods answer validate()'s question without building the
       // error list, so they run the same preprocess pass. Skipping it made the
       // two disagree on input that coercion or a default would have fixed.
-      _bindVerdict(this, preprocess
-        ? (data) => { preprocess(data); return jsFn(data) }
-        : jsFn);
+      _bindVerdict(this, fusedRemove
+        ? (data) => fusedRemove(data) || (preprocess(data), jsFn(data))
+        : preprocess
+          ? (data) => { preprocess(data); return jsFn(data) }
+          : jsFn);
       // Same preference as the object path: the combined function first, since
       // it validates and collects in one pass, and the error generator behind
       // it. `errPreferCombined` is that order, resolved on the first rejection
@@ -1794,7 +1823,12 @@ class Validator {
         : _validate;
       _bindVerdict(this, this._fastVerdict
         ? this._fastVerdict
-        : (data) => _validate(data).valid);
+        // The rewrite runs first here too, as it does for validate() above; a
+        // verdict without it disagreed with validate() on input that coercion,
+        // a default or a removed key would have fixed.
+        : preprocess
+          ? (data) => { preprocess(data); return _validate(data).valid; }
+          : (data) => _validate(data).valid);
       this.validateAndParse = (jsonStr) => this._compiled.validateAndParse(jsonStr);
       {
         const slot = this._fastSlot;
@@ -1927,12 +1961,22 @@ class Validator {
     // paths that only need a boolean.
     if (this.validate) {
       const _bare = this.validate;
-      this.validate = (data) => {
-        const r = _bare(data);
-        return (r.valid === true && r.data === undefined)
-          ? { valid: true, data, errors: r.errors }
-          : r;
-      };
+      this.validate = fusedRemove
+        // A document the removing verdict accepts is answered here, one call
+        // deep; anything else takes the full path, see fusedRemove above.
+        ? (data) => {
+            if (fusedRemove(data)) return { valid: true, data, errors: VALID_RESULT.errors };
+            const r = _bare(data);
+            return (r.valid === true && r.data === undefined)
+              ? { valid: true, data, errors: r.errors }
+              : r;
+          }
+        : (data) => {
+            const r = _bare(data);
+            return (r.valid === true && r.data === undefined)
+              ? { valid: true, data, errors: r.errors }
+              : r;
+          };
     }
 
     // Custom error messages: if any subschema declares an `errorMessage`

package/lib/interpreter.js

@@ -1255,3 +1255,9 @@ function createInterpreter(schema, options) {
 }
 
 module.exports = { createInterpreter };
+// For lib/plan-source.js, which emits source from the same plans and must call
+// the same helpers so the two cannot answer differently.
+Object.defineProperty(module.exports, '_planInternals', {
+  value: { Plan, deepEqual, cpAtLeast, cpAtMost, multipleOfOk, dataBits, T_STRING, T_NUMBER, T_INTEGER, T_BOOLEAN, T_NULL, T_OBJECT, T_ARRAY, T_ANY },
+  enumerable: false,
+});

package/lib/js-compiler.js

@@ -912,17 +912,66 @@ const PROTO_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '_
 // Declared once per compiled function and called by name: spelled out at each
 // property, the test grew a 50-property module by a tenth. Both are small
 // enough for the engine to inline.
-const OWN_HELPERS = 'const _hop=Object.prototype.hasOwnProperty;' +
-  'function _own(o,k){return o.__proto__===Object.prototype?k in o:_hop.call(o,k)}'
+//
+// The `in` stays at the call site with the key as a constant: inside a shared
+// helper the key is a parameter, the engine cannot keep that `in` monomorphic,
+// and reading the errors of a product document went from 3.9 to 5.8 us. The
+// helper only runs once `in` has said yes, and on an ordinary object it
+// answers from the prototype without looking at the key.
+const OWN_HELPERS = 'const _hop=Object.prototype.hasOwnProperty;function _h(o,k){return _hop.call(o,k)}' +
+  'function _ok(o,k){return o.__proto__===Object.prototype||_hop.call(o,k)}' +
+  'function _hall(o,ks){for(let i=0;i<ks.length;i++)if(!_hop.call(o,ks[i]))return false;return true}'
+//
+// Better still, the prototype is read once per object: a node that asks about
+// presence declares `_pkN`, whether its value is an ordinary object, before
+// anything else, and every key test in that node reads the local. A shared
+// helper reading `__proto__` for each key was megamorphic, since it saw every
+// object shape in the document, and cost the error path about a microsecond
+// on a product document.
 function ownKeyExpr (ctx, v, key) {
   hoistOnce(ctx, '_ownHoisted', OWN_HELPERS)
   const k = JSON.stringify(key)
-  return PROTO_NAMES.has(key) ? `_hop.call(${v},${k})` : `_own(${v},${k})`
+  if (PROTO_NAMES.has(key)) return `_h(${v},${k})`
+  const pk = ctx.plainOf ? ctx.plainOf.get(v) : undefined
+  return pk !== undefined ? `(${pk}?${k} in ${v}:_h(${v},${k}))` : `(${k} in ${v}&&_ok(${v},${k}))`
 }
 // For a value already read as `v[key]` and found not to be undefined: whether
-// it came from `v` itself. Same test; `in` is already known to hold.
+// it came from `v` itself. `in` is known to hold, so only the second half runs.
 function ownGuard (ctx, v, key) {
-  return ownKeyExpr(ctx, v, key)
+  hoistOnce(ctx, '_ownHoisted', OWN_HELPERS)
+  const k = JSON.stringify(key)
+  if (PROTO_NAMES.has(key)) return `_h(${v},${k})`
+  const pk = ctx.plainOf ? ctx.plainOf.get(v) : undefined
+  return pk !== undefined ? `(${pk}||_h(${v},${k}))` : `_ok(${v},${k})`
+}
+
+// Declares the per-object prototype flag for a node that asks about presence,
+// and records it for the key tests emitted while the node is generated. The
+// record is restored on the way out, so a nested node over the same value
+// expression, an allOf branch say, cannot leave its name behind.
+function withPlain (schema, v, lines, ctx, run) {
+  if (typeof schema !== 'object' || schema === null ||
+      !(schema.required || schema.properties || schema.dependentRequired || schema.dependentSchemas)) {
+    return run()
+  }
+  if (!ctx.plainOf) ctx.plainOf = new Map()
+  const name = '_pk' + ctx.varCounter++
+  const at = lines.length
+  lines.push(`const ${name}=typeof ${v}==='object'&&${v}!==null&&${v}.__proto__===Object.prototype`)
+  const prev = ctx.plainOf.get(v)
+  ctx.plainOf.set(v, name)
+  try {
+    return run()
+  } finally {
+    if (prev === undefined) ctx.plainOf.delete(v)
+    else ctx.plainOf.set(v, prev)
+    // A node whose keys are all typed never reads the flag; declaring it
+    // anyway cost a strict-object check about five percent. Unused, it goes.
+    const re = new RegExp('\\b' + name + '\\b')
+    let used = false
+    for (let i = at + 1; i < lines.length && !used; i++) if (re.test(lines[i])) used = true
+    if (!used && lines[at] === `const ${name}=typeof ${v}==='object'&&${v}!==null&&${v}.__proto__===Object.prototype`) lines.splice(at, 1)
+  }
 }
 // The same test at run time, for the closure compiler.
 const _hop = Object.prototype.hasOwnProperty
@@ -934,6 +983,56 @@ function hasOwnKey (d, key) {
 const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'toString', 'valueOf',
   'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString'])
 
+// The nodes the removeAdditional pass deletes from, when deleting them during
+// the verdict gives the answer removing them first would, or null when it may
+// not. It may not whenever a keyword could look at a key before it is deleted
+// and pass where it would fail after: minProperties, a const or enum object
+// that holds the extra key, uniqueItems over objects that differ only in one,
+// a branch that requires it, a `required` naming a key the node does not
+// declare. So the whole schema is held to keywords that only look at declared
+// properties or at scalar values. The node set mirrors emitRemovals in
+// index.js: reached through `properties` from the root, with
+// additionalProperties false and at least one declared property.
+const FUSED_REMOVAL_KEYS = new Set(['type', 'properties', 'required', 'additionalProperties', 'items',
+  'minItems', 'maxItems', 'minLength', 'maxLength', 'pattern', 'format', 'minimum', 'maximum',
+  'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf', 'enum', 'const', 'title', 'description',
+  '$comment', '$schema'])
+function fusedRemovalNodes (root) {
+  const isScalar = (x) => x === null || (typeof x !== 'object' && typeof x !== 'function')
+  const safe = (node) => {
+    if (typeof node === 'boolean') return true
+    if (!node || typeof node !== 'object' || Array.isArray(node)) return false
+    for (const k of Object.keys(node)) if (!FUSED_REMOVAL_KEYS.has(k)) return false
+    if (node.enum !== undefined && !(Array.isArray(node.enum) && node.enum.every(isScalar))) return false
+    if (node.const !== undefined && !isScalar(node.const)) return false
+    if (node.properties !== undefined) {
+      if (!node.properties || typeof node.properties !== 'object' || Array.isArray(node.properties)) return false
+      for (const k of Object.keys(node.properties)) if (!safe(node.properties[k])) return false
+    }
+    if (node.additionalProperties === false) {
+      const declared = node.properties ? Object.keys(node.properties) : []
+      if (declared.length === 0) return false
+      if (Array.isArray(node.required) && node.required.some((r) => !declared.includes(r))) return false
+    } else if (node.additionalProperties !== undefined && node.additionalProperties !== true && !safe(node.additionalProperties)) {
+      return false
+    }
+    if (node.items !== undefined && (Array.isArray(node.items) || !safe(node.items))) return false
+    return true
+  }
+  if (!safe(root)) return null
+  const nodes = new Set()
+  const walk = (node) => {
+    if (!node || typeof node !== 'object' || !node.properties) return
+    if (node.additionalProperties === false && Object.keys(node.properties).length > 0) nodes.add(node)
+    for (const k of Object.keys(node.properties)) {
+      const p = node.properties[k]
+      if (p && typeof p === 'object' && p.properties) walk(p)
+    }
+  }
+  walk(root)
+  return nodes.size > 0 ? nodes : null
+}
+
 // Check if all $dynamicRef in a target schema can be resolved via the calling schema's anchors.
 function canResolveDynamicRefs(target, callingSchema, schemaMap) {
   // Collect anchors from calling schema
@@ -1546,9 +1645,18 @@ 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
-function compileToJSCodegen(schema, schemaMap, userFormats) {
+function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
   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
+  // would delete, in the walk the verdict already makes, instead of rejecting
+  // them. Only for schemas where that cannot change an answer; see
+  // fusedRemovalNodes.
+  let removeNodes = null
+  if (opts && opts.removeAdditional) {
+    removeNodes = fusedRemovalNodes(schema)
+    if (removeNodes === null) return null
+  }
 
   if (!sharedCodegenGate(schema, schemaMap)) return null
 
@@ -1608,7 +1716,7 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
   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 }
+  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 lines = []
   genCode(schema, 'd', lines, ctx)
 
@@ -1930,6 +2038,9 @@ function _deferOrInline(ctx, lines, v, check) {
 // 'array'  = we know v is an array
 // 'string' / 'number' / 'integer' = we know the primitive type
 function genCode(schema, v, lines, ctx, knownType) {
+  return withPlain(schema, v, lines, ctx, () => genCodeNode(schema, v, lines, ctx, knownType))
+}
+function genCodeNode(schema, v, lines, ctx, knownType) {
   // A boolean schema is a constant. false rejects whatever reached it; true
   // constrains nothing and emits nothing, which is correct only because the
   // caller's own checks still stand around this call.
@@ -2156,7 +2267,10 @@ function genCode(schema, v, lines, ctx, knownType) {
     // On an object with another prototype the typed ones may be inherited.
     if (typed.length > 0) {
       hoistOnce(ctx, '_ownHoisted', OWN_HELPERS)
-      lines.push(`if(${v}.__proto__!==Object.prototype&&!(${typed.map((k) => `_hop.call(${v},${JSON.stringify(k)})`).join('&&')}))return false`)
+      // Read directly: the object type is already established here, and a
+      // flag declared for this alone costs more than it saves. The list is
+      // built only on that path, which an ordinary object never takes.
+      lines.push(`if(${v}.__proto__!==Object.prototype&&!_hall(${v},${JSON.stringify(typed)}))return false`)
     }
   } else if (schema.required && schema.required.length > 0) {
     const checks = schema.required.map(key => `!${ownKeyExpr(ctx, v, key)}`)
@@ -2316,7 +2430,21 @@ function genCode(schema, v, lines, ctx, knownType) {
   // additionalProperties -- deferred to end of function for better V8 optimization
   // (type checks run first in hot path, expensive prop count check last)
   // Skip if patternProperties is present — it will handle additionalProperties in a unified loop
-  if (schema.additionalProperties === false && schema.properties && !schema.patternProperties) {
+  if (schema.additionalProperties === false && schema.properties && !schema.patternProperties && ctx.removeNodes && ctx.removeNodes.has(schema)) {
+    const kv = `_rk${ctx.varCounter++}`
+    const declared = Object.keys(schema.properties)
+    let loop = `for(var ${kv} in ${v})if(${declared.map((k) => `${kv}!==${JSON.stringify(k)}`).join('&&')})delete ${v}[${kv}]`
+    // When every declared property is required, the verdict has already
+    // established they are all there, so a key count equal to the declared
+    // count means nothing is extra and the deleting walk, which compares every
+    // key against the declared names, need not run.
+    const req = new Set(schema.required || [])
+    if (declared.length <= 15 && declared.every((k) => req.has(k))) {
+      const n = `_rn${ctx.varCounter++}`
+      loop = `{var ${n}=0;for(var ${kv} in ${v})${n}++;if(${n}!==${declared.length}){${loop}}}`
+    }
+    _deferOrInline(ctx, lines, v, isObj ? loop : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${loop}}`)
+  } else if (schema.additionalProperties === false && schema.properties && !schema.patternProperties) {
     const propCount = Object.keys(schema.properties).length
     const allRequired = schema.required && schema.required.length === propCount
     const inner = allRequired
@@ -3731,6 +3859,9 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
 // Instead of `return false`, pushes to `_e` array and optionally early-returns.
 // `_all` parameter: if falsy, return after first error.
 function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  return withPlain(schema, v, lines, ctx, () => genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix))
+}
+function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (!schemaPrefix) schemaPrefix = '#'
   // A false schema reports one error at the value that reached it, with the
   // keyword the interpreter has always used for it, `not` (lib/plan-compiler.js
@@ -4451,6 +4582,9 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
 // After type check passes → use optimizations (destructuring, no guards).
 // If type check fails → push error, skip property checks (they'd crash).
 function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  return withPlain(schema, v, lines, ctx, () => genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix))
+}
+function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (!schemaPrefix) schemaPrefix = '#'
   // Per-node, for the reason spelled out in genCode.
   let ppHandledPropertyNames = false

package/lib/plan-source.js

@@ -0,0 +1,281 @@
+'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' || (typeof x === '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(`(typeof ${v}==='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, `typeof ${v}==='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 };

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.31.2",
+  "version": "1.31.3",
   "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",
@@ -51,7 +51,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_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_version_sync.js && node tests/test_native_loaded.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_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_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_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_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_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_version_sync.js && node tests/test_native_loaded.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_plan_source.js && node tests/test_fused_remove_additional.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_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_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_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",
@@ -121,13 +121,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.31.2",
-    "@ata-validator/native-darwin-x64": "1.31.2",
-    "@ata-validator/native-linux-arm64-gnu": "1.31.2",
-    "@ata-validator/native-linux-arm64-musl": "1.31.2",
-    "@ata-validator/native-linux-x64-gnu": "1.31.2",
-    "@ata-validator/native-linux-x64-musl": "1.31.2",
-    "@ata-validator/native-win32-x64": "1.31.2"
+    "@ata-validator/native-darwin-arm64": "1.31.3",
+    "@ata-validator/native-darwin-x64": "1.31.3",
+    "@ata-validator/native-linux-arm64-gnu": "1.31.3",
+    "@ata-validator/native-linux-arm64-musl": "1.31.3",
+    "@ata-validator/native-linux-x64-gnu": "1.31.3",
+    "@ata-validator/native-linux-x64-musl": "1.31.3",
+    "@ata-validator/native-win32-x64": "1.31.3"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"