ata-validator 1.31.1 → 1.31.3

package/compat.js

@@ -22,7 +22,7 @@ const { resolvePointer } = require('./lib/pointer.js');
 
 const { Validator } = require('./index');
 const { METASCHEMAS } = require('./lib/metaschemas');
-const { createShaper } = require('./lib/compat-errors');
+const { createShaper, asReferenceKeyword } = require('./lib/compat-errors');
 
 const DRAFT7 = 'http://json-schema.org/draft-07/schema#';
 const DRAFT2020 = 'https://json-schema.org/draft/2020-12/schema';
@@ -185,7 +185,7 @@ class Ata {
         validate.errors = null;
         return true;
       }
-      let errors = shaper === null ? result.errors : shaper(result.errors, data);
+      let errors = shaper === null ? result.errors.map(asReferenceKeyword) : shaper(result.errors, data);
       // Errors the shaper synthesises, the `if` wrapper among them, are built
       // from the group rather than carried up from the validator, so verbose
       // mode has to fill in the value they point at here or they would be the

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/compat-errors.js

@@ -133,6 +133,16 @@ function escapePointer(s) {
 // validate() already reports them so.
 const WRAPPERS = new Set(['anyOf', 'oneOf', 'propertyNames', 'contains', 'not', 'if']);
 
+// ata names the keyword of a false schema `not`, at the root and nested alike,
+// which is what its own error codes and every consumer switch on. The
+// reference names it `false schema`. The root case used to come out of the
+// code generator as `false schema` by an inconsistency that has since been
+// fixed, so this shim matched the reference there and not for a nested false
+// schema; the rename here makes both match.
+function asReferenceKeyword(e) {
+  return e.keyword === 'not' && e.message === 'boolean schema is false' ? { ...e, keyword: 'false schema' } : e;
+}
+
 function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors, macroKeywords }) {
   const branchCache = new Map();
   const branchValidator = (pointer) => {
@@ -360,11 +370,11 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
   }
 
   return function shapeErrors(errors, data) {
-    const shaped = shape(errors, data, '');
+    const shaped = shape(errors, data, '').map(asReferenceKeyword);
     if (allErrors) return shaped;
     const n = groupEnd(shaped);
     return shaped.slice(0, n);
   };
 }
 
-module.exports = { createShaper, sortLikeReference, REFERENCE_ORDER };
+module.exports = { createShaper, sortLikeReference, REFERENCE_ORDER, asReferenceKeyword };

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

@@ -157,10 +157,31 @@ const DOC_BASE = 'https://ata-validator.com/e/'
 // reader sorts by without deriving it from the path. Empty when the path is
 // not into the root document.
 function ordinalField (ctx, schemaPath) {
-  const o = ctx && ctx.rootSchema ? ordinalFor(ctx.rootSchema, schemaPath) : null
+  const o = ctx && ctx.rootSchema ? ordinalFor(ctx.rootSchema, unescapeSp(schemaPath)) : null
   return o === null ? '' : `,_o:${o}`
 }
 
+// A schema path as the generators hold it is text for a single-quoted source
+// literal: ptrSeg put a backslash before every backslash and quote in a key.
+// Anything that uses the path as a value, the ordinal lookup and the frozen
+// error objects below, has to take that backslash off again, or a key such as
+// `it's` reads as `it\'s` and the error names a path that does not exist.
+// The value of a string literal the generators built for source. One that does
+// not parse on its own (a key with a raw line break) would not parse inside the
+// generated function either, so the generator declines, as it would have when
+// that function failed to build.
+function literalValue (lit) {
+  try {
+    return Function('return ' + lit)()
+  } catch {
+    throw DECLINE
+  }
+}
+
+function unescapeSp (sp) {
+  return sp.indexOf('\\') === -1 ? sp : sp.replace(/\\(.)/g, '$1')
+}
+
 function buildErrorLiteral (opts) {
   const { keyword, format, schemaPath, sourceMap } = opts
   let code = (keyword === 'format' && format) ? codeFor('format', format) : codeFor(keyword)
@@ -340,7 +361,7 @@ function compileToJS(schema, defs, schemaMap) {
   // required applies to objects only; other types are ignored.
   if (schema.required && Array.isArray(schema.required)) {
     for (const key of schema.required) {
-      checks.push((d) => typeof d !== 'object' || d === null || Array.isArray(d) || d[key] !== undefined)
+      checks.push((d) => typeof d !== 'object' || d === null || Array.isArray(d) || hasOwnKey(d, key))
     }
   }
 
@@ -350,7 +371,7 @@ function compileToJS(schema, defs, schemaMap) {
       const propCheck = compileToJS(prop, rootDefs)
       if (!propCheck) return null // bail if sub-schema too complex
       checks.push((d) => {
-        if (typeof d !== 'object' || d === null || !(key in d)) return true
+        if (typeof d !== 'object' || d === null || !hasOwnKey(d, key)) return true
         return propCheck(d[key])
       })
     }
@@ -387,9 +408,9 @@ function compileToJS(schema, defs, schemaMap) {
   if (schema.dependentRequired) {
     for (const [key, deps] of Object.entries(schema.dependentRequired)) {
       checks.push((d) => {
-        if (typeof d !== 'object' || d === null || !(key in d)) return true
+        if (typeof d !== 'object' || d === null || !hasOwnKey(d, key)) return true
         for (let i = 0; i < deps.length; i++) {
-          if (!(deps[i] in d)) return false
+          if (!hasOwnKey(d, deps[i])) return false
         }
         return true
       })
@@ -872,9 +893,146 @@ const FORMAT_CHECKS = {
 }
 
 // Dangerous JS property names that exist on Object.prototype
+// Presence is an own-property question: `required: ['toString']` is not
+// satisfied by `{}`. `'k' in v` and `v.k !== undefined` both answer yes for a
+// name found on the prototype chain, which accepted documents the interpreted
+// engine rejects. Object.hasOwn would be exact but is not inlined, about 5 ns
+// a key against well under 1 for `in`, so the check is split:
+//   - a name on Object.prototype (and `__proto__`) is always checked with
+//     hasOwnProperty; these are rare in schemas and known when compiling;
+//   - any other name can only be inherited from a prototype that is not
+//     Object.prototype, so an ordinary object answers with `in` and one
+//     comparison of its prototype, and anything else, a class instance, a
+//     null-prototype object, one from another realm, pays for hasOwnProperty.
+// `v.__proto__` is read rather than Object.getPrototypeOf(v) because the engine
+// inlines the accessor and not the call (0.8 ns against 8 for eleven keys). An
+// object whose own `__proto__` is a data property reads that value, which is
+// not Object.prototype, so it takes the exact path.
+const PROTO_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '__proto__'])
+// 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.
+//
+// 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)
+  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. `in` is known to hold, so only the second half runs.
+function ownGuard (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
+function hasOwnKey (d, key) {
+  if (PROTO_NAMES.has(key)) return _hop.call(d, key)
+  return key in d && (d.__proto__ === Object.prototype || _hop.call(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
@@ -1487,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
 
@@ -1549,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)
 
@@ -1871,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.
@@ -2077,24 +2247,37 @@ function genCode(schema, v, lines, ctx, knownType) {
   const hoisted = {} // key -> access expression
   if (schema.required && schema.properties && isObj) {
     const reqChecks = []
+    const typed = []
     for (const key of schema.required) {
       hoisted[key] = `${v}[${JSON.stringify(key)}]`
       const prop = schema.properties[key]
       const hasTypeCheck = prop && (prop.type || prop.enum || prop.const !== undefined)
-      if (!hasTypeCheck) {
-        reqChecks.push(`${v}[${JSON.stringify(key)}]===undefined`)
+      // A typed property needs no separate presence check on an ordinary
+      // object: its type check fails on undefined. A name on Object.prototype
+      // is never absent that way, and it is checked explicitly.
+      if (!hasTypeCheck || PROTO_NAMES.has(key)) {
+        reqChecks.push(`!${ownKeyExpr(ctx, v, key)}`)
+      } else {
+        typed.push(key)
       }
     }
     if (reqChecks.length > 0) {
       lines.push(`if(${reqChecks.join('||')})return false`)
     }
+    // On an object with another prototype the typed ones may be inherited.
+    if (typed.length > 0) {
+      hoistOnce(ctx, '_ownHoisted', OWN_HELPERS)
+      // 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)}`)
     if (isObj) {
-      const checks = schema.required.map(key => `${v}[${JSON.stringify(key)}]===undefined`)
       lines.push(`if(${checks.join('||')})return false`)
     } else {
       // required applies to objects only; other types are ignored.
-      const checks = schema.required.map(key => `${v}[${JSON.stringify(key)}]===undefined`)
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&(${checks.join('||')}))return false`)
     }
   }
@@ -2247,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
@@ -2287,8 +2484,8 @@ function genCode(schema, v, lines, ctx, knownType) {
   // dependentRequired
   if (schema.dependentRequired) {
     for (const [key, deps] of Object.entries(schema.dependentRequired)) {
-      const depChecks = deps.map(d => `!('${esc(d)}' in ${v})`).join('||')
-      lines.push(`if(${objGuard}'${esc(key)}' in ${v}&&(${depChecks}))return false`)
+      const depChecks = deps.map(d => `!${ownKeyExpr(ctx, v, d)}`).join('||')
+      lines.push(`if(${objGuard}${ownKeyExpr(ctx, v, key)}&&(${depChecks}))return false`)
     }
   }
 
@@ -2425,7 +2622,7 @@ function genCode(schema, v, lines, ctx, knownType) {
   if (schema.dependentSchemas) {
     for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
       const guard = isObj ? '' : `typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&`
-      lines.push(`if(${guard}${JSON.stringify(key)} in ${v}){`)
+      lines.push(`if(${guard}${ownKeyExpr(ctx, v, key)}){`)
       ctx.condDepth = (ctx.condDepth || 0) + 1
       genCode(depSchema, v, lines, ctx, effectiveType)
       ctx.condDepth--
@@ -2491,7 +2688,7 @@ function genCode(schema, v, lines, ctx, knownType) {
         // Optional — hoist to local, check undefined
         const oi = ctx.varCounter++
         const local = `_o${oi}`
-        lines.push(`{const ${local}=${v}[${JSON.stringify(key)}];if(${local}!==undefined){`)
+        lines.push(`{const ${local}=${v}[${JSON.stringify(key)}];if(${local}!==undefined&&${ownGuard(ctx, v, key)}){`)
         const combined = tryGenCombined(prop, local, ctx)
         if (combined) {
           lines.push(combined)
@@ -2500,7 +2697,7 @@ function genCode(schema, v, lines, ctx, knownType) {
         }
         lines.push(`}}`)
       } else {
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}){`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}){`)
         genCode(prop, `${v}[${JSON.stringify(key)}]`, lines, ctx)
         lines.push(`}`)
       }
@@ -2864,7 +3061,7 @@ function genCode(schema, v, lines, ctx, knownType) {
           for (const [trigger, depSchema] of Object.entries(schema.dependentSchemas)) {
             const depResult = collectEvaluated(depSchema, ctx.schemaMap, ctx.rootDefs)
             if (depResult.props && depResult.props.length > 0) {
-              lines.push(`if(${JSON.stringify(trigger)} in ${v}){${depResult.props.map(k => `${evVar}[${JSON.stringify(k)}]=1`).join(';')}}`)
+              lines.push(`if(${ownKeyExpr(ctx, v, trigger)}){${depResult.props.map(k => `${evVar}[${JSON.stringify(k)}]=1`).join(';')}}`)
             }
           }
           const inner = `for(var _k in ${v}){if(!${evVar}[_k])return false}`
@@ -3462,7 +3659,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
   if (typeof schema === 'boolean') {
     return schema
       ? () => ({ valid: true, errors: [] })
-      : () => ({ valid: false, errors: [{ keyword: 'false schema', instancePath: '', schemaPath: '#', params: {}, message: 'boolean schema is false' }] })
+      : () => ({ valid: false, errors: [{ keyword: 'not', instancePath: '', schemaPath: '#', params: {}, message: 'boolean schema is false' }] })
   }
   if (typeof schema !== 'object' || schema === null) return null
   if (!sharedCodegenGate(schema, schemaMap)) return null
@@ -3662,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
@@ -3823,7 +4023,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const reqSp = `${schemaPrefix}/required`
     const reqLit = buildErrorLiteral({ keyword: 'required', schemaPath: reqSp, sourceMap: ctx.sourceMap })
     for (const key of schema.required) {
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){_e.push({code:'${reqLit.codeStr}',keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${reqSp}'${ordinalField(ctx, `${reqSp}`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'",docUrl:'${reqLit.docUrl}'${reqLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){_e.push({code:'${reqLit.codeStr}',keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${reqSp}'${ordinalField(ctx, `${reqSp}`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'",docUrl:'${reqLit.docUrl}'${reqLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
     }
   }
 
@@ -4040,7 +4240,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const drLit = buildErrorLiteral({ keyword: 'dependentRequired', schemaPath: drSp, sourceMap: ctx.sourceMap })
     for (const [key, deps] of Object.entries(schema.dependentRequired)) {
       for (const dep of deps) {
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){_e.push({code:'${drLit.codeStr}',keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${drSp}'${ordinalField(ctx, `${drSp}`)},params:{missingProperty:'${esc(dep)}'},message:"must have required property '${esc(dep)}'",docUrl:'${drLit.docUrl}'${drLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}&&!${ownKeyExpr(ctx, v, dep)}){_e.push({code:'${drLit.codeStr}',keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${drSp}'${ordinalField(ctx, `${drSp}`)},params:{missingProperty:'${esc(dep)}'},message:"must have required property '${esc(dep)}'",docUrl:'${drLit.docUrl}'${drLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
       }
     }
   }
@@ -4049,7 +4249,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
       const childPath = childPathExpr(pathExpr, ptrSeg(key))
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
       genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
       lines.push(`}`)
     }
@@ -4118,7 +4318,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // dependentSchemas
   if (schema.dependentSchemas) {
     for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
       genCodeE(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+ptrSeg(key))
       lines.push(`}`)
     }
@@ -4286,7 +4486,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
   if (typeof schema === 'boolean') {
     return schema
       ? () => VALID_RESULT
-      : () => ({ valid: false, errors: [{ keyword: 'false schema', instancePath: '', schemaPath: '#', params: {}, message: 'boolean schema is false' }] })
+      : () => ({ valid: false, errors: [{ keyword: 'not', instancePath: '', schemaPath: '#', params: {}, message: 'boolean schema is false' }] })
   }
   if (typeof schema !== 'object' || schema === null) return null
   if (!sharedCodegenGate(schema, schemaMap)) return null
@@ -4382,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
@@ -4473,14 +4676,28 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         // Static error: pre-allocate as frozen closure variable
         const ei = ctx.varCounter++
         const errVar = `_E${ei}`
-        const pathVal = pathExpr ? pathExpr.slice(1, -1) : ''
-        const msgVal = msgCode.slice(1, -1)
+        // The path and message are source literals; evaluate them rather than
+        // strip the quotes, so an escaped quote or backslash in a key comes
+        // out as the character and not as the escape.
+        let pathVal, msgVal
+        try {
+          pathVal = pathExpr ? Function('return ' + pathExpr)() : ''
+          msgVal = Function('return ' + msgCode)()
+        } catch {
+          // Not a literal that parses on its own (a key with a raw line break):
+          // leave it to the inline form below, which declines the same way the
+          // whole function would.
+          pathVal = undefined
+        }
+        if (pathVal !== undefined) {
+        const spVal = unescapeSp(sp)
         ctx.closureVars.push(errVar)
-        const o = ordinalFor(ctx.rootSchema, sp)
-        const lit = {keyword, instancePath: pathVal, schemaPath: sp, params: Object.freeze(paramsVal), message: msgVal}
+        const o = ordinalFor(ctx.rootSchema, spVal)
+        const lit = {keyword, instancePath: pathVal, schemaPath: spVal, params: Object.freeze(paramsVal), message: msgVal}
         if (o !== null) lit._o = o
         ctx.closureVals.push(Object.freeze(lit))
         return `(_e||(_e=[])).push(${errVar})`
+        }
       }
     }
     // Dynamic path (e.g., array index): inline as before
@@ -4543,15 +4760,22 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         destructKeys.push(`${JSON.stringify(key)}:${lv}`)
       }
     }
-    if (destructKeys.length > 0) lines.push(`const{${destructKeys.join(',')}}=${v}`)
+    if (destructKeys.length > 0) {
+      lines.push(`let{${destructKeys.join(',')}}=${v}`)
+      // A value the object only inherits reads as absent, here and in the
+      // property checks that use the same local below.
+      for (const key of schema.required) {
+        if (hoisted[key]) lines.push(`if(${hoisted[key]}!==undefined&&!${ownGuard(ctx, v, key)})${hoisted[key]}=undefined`)
+      }
+    }
     for (const key of schema.required) {
-      const check = hoisted[key] ? `${hoisted[key]}===undefined` : `${v}[${JSON.stringify(key)}]===undefined`
+      const check = hoisted[key] ? `${hoisted[key]}===undefined` : `!${ownKeyExpr(ctx, v, key)}`
       if (isStaticPath) {
         const ei = ctx.varCounter++
         const errVar = `_E${ei}`
-        const pathVal = pathExpr ? pathExpr.slice(1, -1) : ''
+        const pathVal = pathExpr ? literalValue(pathExpr) : ''
         ctx.closureVars.push(errVar)
-        ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: `${schemaPrefix}/required`, params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}))
+        ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/required`), params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}))
         lines.push(`if(${check}){(_e||(_e=[])).push(${errVar})}`)
       } else {
         lines.push(`if(${check}){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"})}`)
@@ -4563,12 +4787,12 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       if (isStatic) {
         const ei = ctx.varCounter++
         const errVar = `_E${ei}`
-        const pathVal = pathExpr ? pathExpr.slice(1, -1) : ''
+        const pathVal = pathExpr ? literalValue(pathExpr) : ''
         ctx.closureVars.push(errVar)
-        ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: `${schemaPrefix}/required`, params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}))
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){(_e||(_e=[])).push(${errVar})}`)
+        ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/required`), params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}))
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){(_e||(_e=[])).push(${errVar})}`)
       } else {
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"})}`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"})}`)
       }
     }
   }
@@ -4728,12 +4952,12 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         if (isStatic) {
           const ei = ctx.varCounter++
           const errVar = `_E${ei}`
-          const pathVal = pathExpr ? pathExpr.slice(1, -1) : ''
+          const pathVal = pathExpr ? literalValue(pathExpr) : ''
           ctx.closureVars.push(errVar)
-          ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: `${schemaPrefix}/dependentRequired`, params: Object.freeze({missingProperty: dep}), message: `must have required property '${dep}'`}))
-          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){(_e||(_e=[])).push(${errVar})}`)
+          ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/dependentRequired`), params: Object.freeze({missingProperty: dep}), message: `must have required property '${dep}'`}))
+          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}&&!${ownKeyExpr(ctx, v, dep)}){(_e||(_e=[])).push(${errVar})}`)
         } else {
-          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/dependentRequired'${ordinalField(ctx, `${schemaPrefix}/dependentRequired`)},params:{missingProperty:'${esc(dep)}'},message:"must have required property '${esc(dep)}'"})}`)
+          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}&&!${ownKeyExpr(ctx, v, dep)}){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/dependentRequired'${ordinalField(ctx, `${schemaPrefix}/dependentRequired`)},params:{missingProperty:'${esc(dep)}'},message:"must have required property '${esc(dep)}'"})}`)
         }
       }
     }
@@ -4745,16 +4969,17 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       const pv = hoisted[key] || `${v}[${JSON.stringify(key)}]`
       const childPath = childPathExpr(pathExpr, ptrSeg(key))
       if (requiredSet.has(key) && isObj) {
-        lines.push(`if(${pv}!==undefined){`)
+        // A hoisted local was already cleared if the value is only inherited.
+        lines.push(`if(${pv}!==undefined${hoisted[key] ? '' : '&&' + ownGuard(ctx, v, key)}){`)
         genCodeC(prop, pv, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
         lines.push(`}`)
       } else if (isObj) {
         const oi = ctx.varCounter++
-        lines.push(`{const _o${oi}=${v}[${JSON.stringify(key)}];if(_o${oi}!==undefined){`)
+        lines.push(`{const _o${oi}=${v}[${JSON.stringify(key)}];if(_o${oi}!==undefined&&${ownGuard(ctx, v, key)}){`)
         genCodeC(prop, `_o${oi}`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
         lines.push(`}}`)
       } else {
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
         genCodeC(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
         lines.push(`}`)
       }
@@ -4870,7 +5095,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // dependentSchemas
   if (schema.dependentSchemas) {
     for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
       genCodeC(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+ptrSeg(key))
       lines.push(`}`)
     }

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/shape-classifier.js

@@ -69,6 +69,15 @@ function isTier0Object(schema) {
     for (const r of schema.required) if (typeof r !== 'string') return false;
   }
   const props = schema.properties;
+  // The tier-0 validator checks presence through the per-property constraints,
+  // so a required name with no entry in properties was never checked at all:
+  // `{ type: 'object', required: ['id'] }` accepted `{}` until the schema moved
+  // to generated code, and for good when the generator declined it.
+  if (schema.required !== undefined) {
+    for (const r of schema.required) {
+      if (props === undefined || props === null || typeof props !== 'object' || !Object.prototype.hasOwnProperty.call(props, r)) return false;
+    }
+  }
   if (props === undefined) return true;
   if (typeof props !== 'object' || props === null || Array.isArray(props)) return false;
   const keys = Object.keys(props);

package/lib/tier0.js

@@ -41,6 +41,12 @@ const F_MULT = 16;
 
 // Build a constraint tuple for one primitive-typed property.
 // All fields have the same layout so every constraint shares one hidden class.
+// Names found on Object.prototype. For these a read of data[key] finds the
+// inherited value on every ordinary object, so presence is asked of the object
+// itself; see ownKeyExpr in js-compiler.js.
+const PROTO_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '__proto__']);
+const _hop = Object.prototype.hasOwnProperty;
+
 function primConstraint(key, propSchema) {
   const t = propSchema.type;
   const hasEnum = Array.isArray(propSchema.enum);
@@ -53,6 +59,7 @@ function primConstraint(key, propSchema) {
   if (typeof propSchema.multipleOf === 'number') numFlags |= F_MULT;
   return {
     key,
+    protoName: PROTO_NAMES.has(key),
     typeMask: TYPE_MASK[t] | 0,
     numFlags,
     hasEnum,
@@ -159,7 +166,10 @@ function tier0ValidateObject(plan, data) {
   let seenMask = 0;
   for (let i = 0; i < n; i++) {
     const c = cs[i];
-    const v = data[c.key];
+    let v = data[c.key];
+    // Presence is an own-property question: a value the object inherits is
+    // treated as absent, as the interpreted engine treats it.
+    if (v !== undefined && (c.protoName || data.__proto__ !== Object.prototype) && !_hop.call(data, c.key)) v = undefined;
     if (v === undefined) {
       if (reqMask & (1 << i)) return false;
       continue;

package/lib/version.js

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

package/package.json

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