ata-validator 1.31.3 → 1.32.1

package/index.d.ts

@@ -497,6 +497,16 @@ export interface Validator<T = unknown> {
   /** Parse JSON and validate against the schema. Returns the parsed value and the validation result. Works without the native addon. */
   validateAndParse(jsonString: string | Buffer): ValidateAndParseResult<T>;
 
+  /**
+   * Validate, then return a copy holding only the properties the schema declares, with defaults
+   * filled. The input is not modified. Throws an error named `AtaValidationError`, with `errors`,
+   * when the value is invalid, and a `TypeError` where the kept key set cannot be proven from the
+   * schema (a $ref it cannot inline, patternProperties, an object that allows unknown keys) or the
+   * validator rewrites input (`coerceTypes`, custom keywords). Same result as the `parse` export of
+   * a module built with `ata build`.
+   */
+  parse(data: unknown): T;
+
   /** Ultra-fast buffer validation via native addon */
   isValid(input: Buffer | Uint8Array | string): boolean;
 

package/index.js

@@ -2895,6 +2895,59 @@ Validator.prototype._extendValidate = function (resolve) {
 // closure, where wrapping the five entry points cost a closure per entry point,
 // the wrappers themselves and an accessor, most of what building a wrapped
 // validator took.
+// parse(data): validate, then return a copy holding only what the schema
+// declares, the way the parse() export of an ahead-of-time module does, with
+// the same emitter behind both. Building the copy from the schema's own key
+// list costs less than finding and deleting unknown keys, and leaves the
+// caller's object alone. Where the key set cannot be proven (a $ref it cannot
+// inline, patternProperties, an open object) the method declines with an
+// error instead of guessing, as the module ships no parse() there; so it does
+// under options that rewrite input, whose answers a copy would not reproduce.
+Validator.prototype.parse = function (data) {
+  let fn = this._parseFn;
+  if (fn === undefined) {
+    fn = _buildParse(this);
+    Object.defineProperty(this, '_parseFn', { value: fn, writable: true, configurable: true, enumerable: false });
+  }
+  return fn(data);
+};
+
+function _buildParse(self) {
+  const decline = (why) => () => {
+    throw new TypeError(`parse() is not available for this validator: ${why}. Use validate() with removeAdditional instead.`);
+  };
+  const o = self._options;
+  if (o.coerceTypes || o.removeAdditional === 'all' || self._usesKeywords || self._verdictTail !== null || self._validateTail !== null) {
+    return decline('its options or keywords rewrite or extend what the schema checks');
+  }
+  const { cloneExprFor } = require('./lib/clone-emit');
+  const expr = cloneExprFor(self._schemaObj);
+  if (!expr) return decline('the set of keys to keep cannot be proven from the schema');
+  let copy;
+  try {
+    // eslint-disable-next-line no-new-func
+    copy = new Function('data', 'return ' + expr);
+  } catch {
+    return decline('code generation is not allowed here');
+  }
+  self._ensureCompiled();
+  const verdict = self._jsFn;
+  if (typeof verdict !== 'function') return decline('the schema has no generated verdict function');
+  return (data) => {
+    if (!verdict(data)) {
+      const e = new Error('validation failed');
+      e.name = 'AtaValidationError';
+      let target = data;
+      if (self._mutatesInput) {
+        try { target = structuredClone(data); } catch { target = data; }
+      }
+      e.errors = self.validate(target).errors;
+      throw e;
+    }
+    return copy(data);
+  };
+}
+
 Validator.prototype._extendChecks = function (resolve) {
   if (typeof resolve !== 'function') throw new TypeError('_extendChecks expects a function');
   this._extendValidate(resolve);

package/lib/aot-impl.js

@@ -189,277 +189,7 @@ function emitFormatDecls(closures, mode, declKW) {
   return { decls: out, exportsSetFormats: false };
 }
 
-// Emit an expression that rebuilds `access` from the properties the schema
-// declares, dropping everything else. This is the sanitising counterpart to
-// removeAdditional: instead of enumerating the input and deleting the keys
-// that do not belong, it reads only the keys that do. That is O(schema)
-// rather than O(input), it leaves the caller's object untouched, and it keeps
-// one hidden class instead of walking the object through a transition per
-// delete.
-//
-// Returns null when the clone cannot be proven exact, and the module then
-// simply has no parse(). Declining is recoverable; a sanitiser that quietly
-// drops a property the schema allows is not.
-// Resolve a local JSON pointer ('#', '#/$defs/x', draft-7 '#/definitions/x',
-// any '#/...' path) against the schema root. Returns null for anything else:
-// external documents, anchors, URNs. Those stay with the runtime engines.
-function resolveLocalPointer(root, ref) {
-  if (ref === '#') return root;
-  if (typeof ref !== 'string' || !ref.startsWith('#/')) return null;
-  let cur = root;
-  for (const raw of ref.slice(2).split('/')) {
-    let seg = raw.replace(/~1/g, '/').replace(/~0/g, '~');
-    if (cur === null || typeof cur !== 'object') return null;
-    if (!Object.prototype.hasOwnProperty.call(cur, seg)) {
-      try { seg = decodeURIComponent(seg); } catch (_) { return null; }
-      if (!Object.prototype.hasOwnProperty.call(cur, seg)) return null;
-    }
-    cur = cur[seg];
-  }
-  return cur;
-}
-
-// Inline local, acyclic $refs before the clone proof runs, so a generated
-// schema ($defs + $ref, the shape every schema generator emits) can still get
-// a parse(). Only a node that is exactly a $ref plus annotations is replaced;
-// a $ref with a constraining sibling, a cycle, an unresolvable target or an
-// external reference is left in place, and emitClone declines it as before.
-// The walk never mutates its input and never descends into data positions
-// (default, const, enum, examples), where an object holding a "$ref" key is
-// a value, not a schema.
-const _INLINE_ANNOTATIONS = new Set(['$ref', 'title', 'description', '$comment', 'examples', 'deprecated', 'readOnly', 'writeOnly', 'default']);
-const _INLINE_DATA_KEYS = new Set(['default', 'const', 'enum', 'examples']);
-function inlineRefsForClone(root) {
-  const state = { budget: 512 };
-  // `inRef` marks content brought in from behind a reference. The runtime's
-  // useDefaults fills a default written next to the $ref, and does not fill
-  // defaults written inside the referenced definition, so the inlined copy
-  // keeps the first and drops the second. parse() must stay exactly as
-  // generous as validate(); a parse that fills more is a disagreement, not a
-  // feature.
-  const walk = (node, active, inRef) => {
-    if (!node || typeof node !== 'object') return node;
-    if (Array.isArray(node)) return node.map((n) => walk(n, active, inRef));
-    let cur = node;
-    let entered = false;
-    let siblingDefault;
-    while (cur && typeof cur === 'object' && !Array.isArray(cur) && typeof cur.$ref === 'string') {
-      for (const k of Object.keys(cur)) if (!_INLINE_ANNOTATIONS.has(k)) return node;
-      if (active.has(cur.$ref) || state.budget-- <= 0) return node;
-      const target = resolveLocalPointer(root, cur.$ref);
-      if (!target || typeof target !== 'object' || Array.isArray(target)) return node;
-      if (!entered && !inRef && cur.default !== undefined) siblingDefault = cur.default;
-      active = new Set(active);
-      active.add(cur.$ref);
-      cur = target;
-      entered = true;
-    }
-    const strip = inRef || entered;
-    const out = {};
-    for (const k of Object.keys(cur)) {
-      if (strip && k === 'default') continue;
-      const v = cur[k];
-      if (_INLINE_DATA_KEYS.has(k) || k === '$defs' || k === 'definitions') { out[k] = v; continue; }
-      out[k] = walk(v, active, strip);
-    }
-    if (siblingDefault !== undefined) out.default = siblingDefault;
-    return out;
-  };
-  return walk(root, new Set(), false);
-}
-
-function emitClone(node, access, depth) {
-  if (!node || typeof node !== 'object') return null;
-  if (depth > 12) return null;
-  // Only plain object nodes are cloneable, and only when the schema names
-  // every property it keeps. A $ref means the set of allowed keys is not
-  // this node's to decide. In-place applicators (allOf, anyOf, oneOf,
-  // if/then/else) are admitted under the same proof the unevaluated* error
-  // generators use: every property name they contribute must already be
-  // declared in this node's own `properties`, so they constrain values but
-  // never widen the key set. `not` never widens it. `unevaluatedProperties`
-  // is admitted only as `false` under that proof, where it is exactly
-  // `additionalProperties: false`.
-  if (node.$ref || node.patternProperties || node.additionalProperties === true) {
-    return null;
-  }
-  // additionalProperties as a schema is the record shape (z.record and every
-  // generator's map type): the key set is open by declaration, so keeping
-  // every key is exact, and every undeclared value is rebuilt against that
-  // one schema. That is a proof, not a guess, so it is admitted. What stays
-  // out: applicators next to a record (a branch could constrain some keys'
-  // values beyond the record schema, and the rebuild would ignore it), and
-  // `additionalProperties: true`, where the value is unconstrained and this
-  // pass only copies what it can name. An open object with no
-  // `additionalProperties` at all also stays out, for the original reason:
-  // validate() accepts its unknown keys, so a parse() that strips them would
-  // silently drop allowed data, and one that keeps them raw would not be a
-  // sanitiser.
-  const apSchema = (node.additionalProperties && typeof node.additionalProperties === 'object')
-    ? node.additionalProperties
-    : null;
-  if (apSchema) {
-    if (node.unevaluatedProperties !== undefined) return null;
-    if (node.allOf || node.anyOf || node.oneOf || node.if || node.then || node.else ||
-        node.dependentSchemas !== undefined || node.dependencies !== undefined ||
-        node.$dynamicRef !== undefined || node.$recursiveRef !== undefined) return null;
-  }
-  if (node.unevaluatedProperties !== undefined && node.unevaluatedProperties !== false) return null;
-  if (node.type !== 'object') return null;
-  if (!node.properties && !apSchema) return null;
-  const keys = node.properties ? Object.keys(node.properties) : [];
-  if (keys.length === 0 && !apSchema) return null;
-  if (node.allOf || node.anyOf || node.oneOf || node.if || node.then || node.else ||
-      node.unevaluatedProperties === false) {
-    if (node.$dynamicRef !== undefined || node.$recursiveRef !== undefined ||
-        node.dependentSchemas !== undefined || node.dependencies !== undefined) return null;
-    const names = new Set();
-    const state = { prefix: 0 };
-    for (const k of ['allOf', 'anyOf', 'oneOf']) {
-      if (node[k] !== undefined) {
-        if (!Array.isArray(node[k])) return null;
-        for (const b of node[k]) if (!unevalContributions(b, 'props', names, state, 0)) return null;
-      }
-    }
-    for (const k of ['if', 'then', 'else']) {
-      if (node[k] !== undefined && !unevalContributions(node[k], 'props', names, state, 0)) return null;
-    }
-    for (const n of names) if (!Object.prototype.hasOwnProperty.call(node.properties, n)) return null;
-  }
-  const required = new Set(Array.isArray(node.required) ? node.required : []);
-
-  const fixed = [];
-  const conditional = [];
-  for (const key of keys) {
-    const prop = node.properties[key];
-    if (!prop || typeof prop !== 'object') return null;
-    if (prop.$ref) return null;
-    // A property that is required and carries a default is the one place the
-    // runtime and a raw-input validation disagree: the runtime fills the
-    // default before checking `required`, so `{}` validates there and would
-    // throw here. Declining keeps parse() exactly as strict as validate().
-    if (required.has(key) && prop.default !== undefined) return null;
-    // A default the property's own schema rejects would make parse() hand
-    // back a document validate() refuses: the runtime fills defaults before
-    // validating, so it catches the bad default, and a raw-input check here
-    // never sees it. Probe the default at emit time and decline when it does
-    // not hold, or when the subschema cannot be compiled to check it.
-    if (prop.default !== undefined) {
-      let probe = null;
-      try { probe = compileToJSCodegen(prop, null, null); } catch (_) { probe = null; }
-      if (!probe || !probe(prop.default)) return null;
-    }
-    const read = `${access}[${JSON.stringify(key)}]`;
-    const value = emitValueExpr(prop, read, depth);
-    if (value === null) return null;
-    // Computed key syntax: a plain `"__proto__":` in an object literal is
-    // the prototype slot, not a property; `["__proto__"]:` is a property.
-    if (required.has(key)) fixed.push(`[${JSON.stringify(key)}]: ${value}`);
-    else conditional.push({ key, value, dflt: prop.default });
-  }
-  if (fixed.length === 0 && conditional.length === 0 && !apSchema) return null;
-
-  const tmp = `_c${depth}`;
-  // The record loop: every key of the input that is not a declared property
-  // is kept, its value rebuilt against the additionalProperties schema. The
-  // input is already validated, so every such value satisfies that schema;
-  // the rebuild only strips inside it. Defaults under a record value are
-  // dropped before emission because the runtime's useDefaults does not fill
-  // them there, and parse() must equal validate().data, not improve on it.
-  let recordLoop = '';
-  if (apSchema) {
-    const kVar = `_k${depth}`;
-    const vVar = `_v${depth}`;
-    const valueExpr = emitValueExpr(stripDefaultsDeep(apSchema), vVar, depth);
-    if (valueExpr === null) return null;
-    let skip = '';
-    let declSet = '';
-    if (keys.length > 8) {
-      declSet = `const _d${depth} = new Set(${JSON.stringify(keys)}); `;
-      skip = `if (_d${depth}.has(${kVar})) continue; `;
-    } else if (keys.length > 0) {
-      skip = `if (${keys.map((k) => `${kVar} === ${JSON.stringify(k)}`).join(' || ')}) continue; `;
-    }
-    // The key comes from the input, so it can be the string "__proto__" (an
-    // own key only JSON.parse writes); assignment would hit the prototype
-    // setter, so that one key goes through defineProperty.
-    recordLoop = ` ${declSet}for (const ${kVar} of Object.keys(${access})) { ${skip}const ${vVar} = ${access}[${kVar}]; if (${kVar} === "__proto__") Object.defineProperty(${tmp}, ${kVar}, { value: ${valueExpr}, writable: true, enumerable: true, configurable: true }); else ${tmp}[${kVar}] = ${valueExpr}; }`;
-  }
-
-  const literal = `{ ${fixed.join(', ')} }`;
-  if (conditional.length === 0 && !recordLoop) return literal;
-  // Optional properties are added only when present, so the result never
-  // gains a key the input did not have.
-  const adds = conditional
-    .map(({ key, value, dflt }) => {
-      // Object.hasOwn, not `in`: `in` also answers for what the instance
-      // inherits, so a property named `constructor` would copy the inherited
-      // function into the output that validate().data does not carry. And a
-      // key named `__proto__` cannot be written by assignment, which hits
-      // the prototype setter; defineProperty writes an own key.
-      const assign = key === '__proto__'
-        ? `Object.defineProperty(${tmp}, ${JSON.stringify(key)}, { value: ${value}, writable: true, enumerable: true, configurable: true });`
-        : `${tmp}[${JSON.stringify(key)}] = ${value};`;
-      const set = `if (Object.hasOwn(${access}, ${JSON.stringify(key)})) ${assign}`;
-      // The default is emitted as a literal inside the call, so an object or
-      // array default is a fresh value on every parse, never shared state.
-      if (dflt === undefined) return set;
-      const setDflt = key === '__proto__'
-        ? `Object.defineProperty(${tmp}, ${JSON.stringify(key)}, { value: ${JSON.stringify(dflt)}, writable: true, enumerable: true, configurable: true });`
-        : `${tmp}[${JSON.stringify(key)}] = ${JSON.stringify(dflt)};`;
-      return `${set} else ${setDflt}`;
-    })
-    .join(' ');
-  return `(function(){ const ${tmp} = ${literal}; ${adds}${recordLoop} return ${tmp}; })()`;
-}
-
-// The value dispatch shared by declared properties and the record loop. A
-// value is copyable only when the emitter can name everything that may live
-// under it: a primitive holds nothing, an object with declared properties or
-// a record schema is rebuilt the same way, an array of primitives has
-// nowhere to hide a key. A $ref, a composition or an untyped node could all
-// carry keys this code cannot see, and copying the reference would smuggle
-// them into a value that claims to be sanitised, so the caller declines the
-// whole clone instead.
-// Drop every schema-position `default` in a subtree, leaving data positions
-// (const, enum, examples) untouched. Used on a record's value schema, where
-// the runtime's useDefaults fills nothing.
-function stripDefaultsDeep(node) {
-  if (!node || typeof node !== 'object') return node;
-  if (Array.isArray(node)) return node.map(stripDefaultsDeep);
-  const out = {};
-  for (const k of Object.keys(node)) {
-    if (k === 'default') continue;
-    out[k] = _INLINE_DATA_KEYS.has(k) ? node[k] : stripDefaultsDeep(node[k]);
-  }
-  return out;
-}
-
-const _CLONE_PRIMITIVE = new Set(['string', 'number', 'integer', 'boolean', 'null']);
-function emitValueExpr(prop, read, depth) {
-  if (!prop || typeof prop !== 'object') return null;
-  if (prop.$ref) return null;
-  const types = Array.isArray(prop.type) ? prop.type : [prop.type];
-  if (types.every((t) => _CLONE_PRIMITIVE.has(t))) return read;
-  const isRecordable = (s) => s.properties ||
-    (s.additionalProperties && typeof s.additionalProperties === 'object');
-  if (prop.type === 'object' && isRecordable(prop)) {
-    return emitClone(prop, read, depth + 1);
-  }
-  if (prop.type === 'array' && prop.items && typeof prop.items === 'object' &&
-      !Array.isArray(prop.items)) {
-    const it = prop.items;
-    const itemTypes = Array.isArray(it.type) ? it.type : [it.type];
-    if (itemTypes.every((t) => _CLONE_PRIMITIVE.has(t))) return read;
-    if (it.type === 'object' && isRecordable(it)) {
-      const el = '_e' + depth;
-      const inner = emitClone(it, el, depth + 1);
-      if (!inner) return null;
-      return `${read}.map((${el}) => (${inner}))`;
-    }
-  }
-  return null;
-}
+const { emitClone, inlineRefsForClone } = require('./clone-emit');
 
 function toStandaloneModule(validator, opts) {
   assertEmittable(validator, 'toStandaloneModule');

package/lib/clone-emit.js

@@ -0,0 +1,302 @@
+'use strict';
+
+// The copy behind parse(): shared by the parse() export of an ahead-of-time
+// module (lib/aot-impl.js) and the runtime's Validator#parse (index.js). It
+// lives apart from the module emitter so the runtime can use it without
+// pulling the emitter, and the safe-regex source it embeds, into a browser
+// bundle.
+
+const { compileToJSCodegen, unevalContributions } = require('./js-compiler');
+
+// Emit an expression that rebuilds `access` from the properties the schema
+// declares, dropping everything else. This is the sanitising counterpart to
+// removeAdditional: instead of enumerating the input and deleting the keys
+// that do not belong, it reads only the keys that do. That is O(schema)
+// rather than O(input), it leaves the caller's object untouched, and it keeps
+// one hidden class instead of walking the object through a transition per
+// delete.
+//
+// Returns null when the clone cannot be proven exact, and the module then
+// simply has no parse(). Declining is recoverable; a sanitiser that quietly
+// drops a property the schema allows is not.
+// Resolve a local JSON pointer ('#', '#/$defs/x', draft-7 '#/definitions/x',
+// any '#/...' path) against the schema root. Returns null for anything else:
+// external documents, anchors, URNs. Those stay with the runtime engines.
+function resolveLocalPointer(root, ref) {
+  if (ref === '#') return root;
+  if (typeof ref !== 'string' || !ref.startsWith('#/')) return null;
+  let cur = root;
+  for (const raw of ref.slice(2).split('/')) {
+    let seg = raw.replace(/~1/g, '/').replace(/~0/g, '~');
+    if (cur === null || typeof cur !== 'object') return null;
+    if (!Object.prototype.hasOwnProperty.call(cur, seg)) {
+      try { seg = decodeURIComponent(seg); } catch (_) { return null; }
+      if (!Object.prototype.hasOwnProperty.call(cur, seg)) return null;
+    }
+    cur = cur[seg];
+  }
+  return cur;
+}
+
+// Inline local, acyclic $refs before the clone proof runs, so a generated
+// schema ($defs + $ref, the shape every schema generator emits) can still get
+// a parse(). Only a node that is exactly a $ref plus annotations is replaced;
+// a $ref with a constraining sibling, a cycle, an unresolvable target or an
+// external reference is left in place, and emitClone declines it as before.
+// The walk never mutates its input and never descends into data positions
+// (default, const, enum, examples), where an object holding a "$ref" key is
+// a value, not a schema.
+const _INLINE_ANNOTATIONS = new Set(['$ref', 'title', 'description', '$comment', 'examples', 'deprecated', 'readOnly', 'writeOnly', 'default']);
+const _INLINE_DATA_KEYS = new Set(['default', 'const', 'enum', 'examples']);
+function inlineRefsForClone(root) {
+  const state = { budget: 512 };
+  // `inRef` marks content brought in from behind a reference. The runtime's
+  // useDefaults fills a default written next to the $ref, and does not fill
+  // defaults written inside the referenced definition, so the inlined copy
+  // keeps the first and drops the second. parse() must stay exactly as
+  // generous as validate(); a parse that fills more is a disagreement, not a
+  // feature.
+  const walk = (node, active, inRef) => {
+    if (!node || typeof node !== 'object') return node;
+    if (Array.isArray(node)) return node.map((n) => walk(n, active, inRef));
+    let cur = node;
+    let entered = false;
+    let siblingDefault;
+    while (cur && typeof cur === 'object' && !Array.isArray(cur) && typeof cur.$ref === 'string') {
+      for (const k of Object.keys(cur)) if (!_INLINE_ANNOTATIONS.has(k)) return node;
+      if (active.has(cur.$ref) || state.budget-- <= 0) return node;
+      const target = resolveLocalPointer(root, cur.$ref);
+      if (!target || typeof target !== 'object' || Array.isArray(target)) return node;
+      if (!entered && !inRef && cur.default !== undefined) siblingDefault = cur.default;
+      active = new Set(active);
+      active.add(cur.$ref);
+      cur = target;
+      entered = true;
+    }
+    const strip = inRef || entered;
+    const out = {};
+    for (const k of Object.keys(cur)) {
+      if (strip && k === 'default') continue;
+      const v = cur[k];
+      if (_INLINE_DATA_KEYS.has(k) || k === '$defs' || k === 'definitions') { out[k] = v; continue; }
+      out[k] = walk(v, active, strip);
+    }
+    if (siblingDefault !== undefined) out.default = siblingDefault;
+    return out;
+  };
+  return walk(root, new Set(), false);
+}
+
+const PROTO_KEY_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '__proto__']);
+
+function emitClone(node, access, depth) {
+  if (!node || typeof node !== 'object') return null;
+  if (depth > 12) return null;
+  // Only plain object nodes are cloneable, and only when the schema names
+  // every property it keeps. A $ref means the set of allowed keys is not
+  // this node's to decide. In-place applicators (allOf, anyOf, oneOf,
+  // if/then/else) are admitted under the same proof the unevaluated* error
+  // generators use: every property name they contribute must already be
+  // declared in this node's own `properties`, so they constrain values but
+  // never widen the key set. `not` never widens it. `unevaluatedProperties`
+  // is admitted only as `false` under that proof, where it is exactly
+  // `additionalProperties: false`.
+  if (node.$ref || node.patternProperties || node.additionalProperties === true) {
+    return null;
+  }
+  // additionalProperties as a schema is the record shape (z.record and every
+  // generator's map type): the key set is open by declaration, so keeping
+  // every key is exact, and every undeclared value is rebuilt against that
+  // one schema. That is a proof, not a guess, so it is admitted. What stays
+  // out: applicators next to a record (a branch could constrain some keys'
+  // values beyond the record schema, and the rebuild would ignore it), and
+  // `additionalProperties: true`, where the value is unconstrained and this
+  // pass only copies what it can name. An open object with no
+  // `additionalProperties` at all also stays out, for the original reason:
+  // validate() accepts its unknown keys, so a parse() that strips them would
+  // silently drop allowed data, and one that keeps them raw would not be a
+  // sanitiser.
+  const apSchema = (node.additionalProperties && typeof node.additionalProperties === 'object')
+    ? node.additionalProperties
+    : null;
+  if (apSchema) {
+    if (node.unevaluatedProperties !== undefined) return null;
+    if (node.allOf || node.anyOf || node.oneOf || node.if || node.then || node.else ||
+        node.dependentSchemas !== undefined || node.dependencies !== undefined ||
+        node.$dynamicRef !== undefined || node.$recursiveRef !== undefined) return null;
+  }
+  if (node.unevaluatedProperties !== undefined && node.unevaluatedProperties !== false) return null;
+  if (node.type !== 'object') return null;
+  if (!node.properties && !apSchema) return null;
+  const keys = node.properties ? Object.keys(node.properties) : [];
+  if (keys.length === 0 && !apSchema) return null;
+  if (node.allOf || node.anyOf || node.oneOf || node.if || node.then || node.else ||
+      node.unevaluatedProperties === false) {
+    if (node.$dynamicRef !== undefined || node.$recursiveRef !== undefined ||
+        node.dependentSchemas !== undefined || node.dependencies !== undefined) return null;
+    const names = new Set();
+    const state = { prefix: 0 };
+    for (const k of ['allOf', 'anyOf', 'oneOf']) {
+      if (node[k] !== undefined) {
+        if (!Array.isArray(node[k])) return null;
+        for (const b of node[k]) if (!unevalContributions(b, 'props', names, state, 0)) return null;
+      }
+    }
+    for (const k of ['if', 'then', 'else']) {
+      if (node[k] !== undefined && !unevalContributions(node[k], 'props', names, state, 0)) return null;
+    }
+    for (const n of names) if (!Object.prototype.hasOwnProperty.call(node.properties, n)) return null;
+  }
+  const required = new Set(Array.isArray(node.required) ? node.required : []);
+
+  const fixed = [];
+  const conditional = [];
+  for (const key of keys) {
+    const prop = node.properties[key];
+    if (!prop || typeof prop !== 'object') return null;
+    if (prop.$ref) return null;
+    // A property that is required and carries a default is the one place the
+    // runtime and a raw-input validation disagree: the runtime fills the
+    // default before checking `required`, so `{}` validates there and would
+    // throw here. Declining keeps parse() exactly as strict as validate().
+    if (required.has(key) && prop.default !== undefined) return null;
+    // A default the property's own schema rejects would make parse() hand
+    // back a document validate() refuses: the runtime fills defaults before
+    // validating, so it catches the bad default, and a raw-input check here
+    // never sees it. Probe the default at emit time and decline when it does
+    // not hold, or when the subschema cannot be compiled to check it.
+    if (prop.default !== undefined) {
+      let probe = null;
+      try { probe = compileToJSCodegen(prop, null, null); } catch (_) { probe = null; }
+      if (!probe || !probe(prop.default)) return null;
+    }
+    const read = `${access}[${JSON.stringify(key)}]`;
+    const value = emitValueExpr(prop, read, depth);
+    if (value === null) return null;
+    // A plain `"__proto__":` in an object literal is the prototype slot, not
+    // a property; `["__proto__"]:` is a property. Only that key is written as
+    // a computed one: a literal with computed keys cannot use the engine's
+    // literal boilerplate and is built key by key, which made the copy cost
+    // about as much as the validation in front of it.
+    if (required.has(key)) fixed.push(key === '__proto__' ? `[${JSON.stringify(key)}]: ${value}` : `${JSON.stringify(key)}: ${value}`);
+    else conditional.push({ key, value, dflt: prop.default });
+  }
+  if (fixed.length === 0 && conditional.length === 0 && !apSchema) return null;
+
+  const tmp = `_c${depth}`;
+  // The record loop: every key of the input that is not a declared property
+  // is kept, its value rebuilt against the additionalProperties schema. The
+  // input is already validated, so every such value satisfies that schema;
+  // the rebuild only strips inside it. Defaults under a record value are
+  // dropped before emission because the runtime's useDefaults does not fill
+  // them there, and parse() must equal validate().data, not improve on it.
+  let recordLoop = '';
+  if (apSchema) {
+    const kVar = `_k${depth}`;
+    const vVar = `_v${depth}`;
+    const valueExpr = emitValueExpr(stripDefaultsDeep(apSchema), vVar, depth);
+    if (valueExpr === null) return null;
+    let skip = '';
+    let declSet = '';
+    if (keys.length > 8) {
+      declSet = `const _d${depth} = new Set(${JSON.stringify(keys)}); `;
+      skip = `if (_d${depth}.has(${kVar})) continue; `;
+    } else if (keys.length > 0) {
+      skip = `if (${keys.map((k) => `${kVar} === ${JSON.stringify(k)}`).join(' || ')}) continue; `;
+    }
+    // The key comes from the input, so it can be the string "__proto__" (an
+    // own key only JSON.parse writes); assignment would hit the prototype
+    // setter, so that one key goes through defineProperty.
+    recordLoop = ` ${declSet}for (const ${kVar} of Object.keys(${access})) { ${skip}const ${vVar} = ${access}[${kVar}]; if (${kVar} === "__proto__") Object.defineProperty(${tmp}, ${kVar}, { value: ${valueExpr}, writable: true, enumerable: true, configurable: true }); else ${tmp}[${kVar}] = ${valueExpr}; }`;
+  }
+
+  const literal = `{ ${fixed.join(', ')} }`;
+  if (conditional.length === 0 && !recordLoop) return literal;
+  // Optional properties are added only when present, so the result never
+  // gains a key the input did not have.
+  const adds = conditional
+    .map(({ key, value, dflt }) => {
+      // Object.hasOwn, not `in`: `in` also answers for what the instance
+      // inherits, so a property named `constructor` would copy the inherited
+      // function into the output that validate().data does not carry. And a
+      // key named `__proto__` cannot be written by assignment, which hits
+      // the prototype setter; defineProperty writes an own key.
+      const assign = key === '__proto__'
+        ? `Object.defineProperty(${tmp}, ${JSON.stringify(key)}, { value: ${value}, writable: true, enumerable: true, configurable: true });`
+        : `${tmp}[${JSON.stringify(key)}] = ${value};`;
+      // The same own-property test the generators emit, since Object.hasOwn
+      // is not inlined: `in`, then the prototype, then hasOwnProperty only
+      // for an object that is not an ordinary one.
+      const k = JSON.stringify(key);
+      const own = PROTO_KEY_NAMES.has(key)
+        ? `Object.prototype.hasOwnProperty.call(${access}, ${k})`
+        : `(${k} in ${access} && (${access}.__proto__ === Object.prototype || Object.prototype.hasOwnProperty.call(${access}, ${k})))`;
+      const set = `if (${own}) ${assign}`;
+      // The default is emitted as a literal inside the call, so an object or
+      // array default is a fresh value on every parse, never shared state.
+      if (dflt === undefined) return set;
+      const setDflt = key === '__proto__'
+        ? `Object.defineProperty(${tmp}, ${JSON.stringify(key)}, { value: ${JSON.stringify(dflt)}, writable: true, enumerable: true, configurable: true });`
+        : `${tmp}[${JSON.stringify(key)}] = ${JSON.stringify(dflt)};`;
+      return `${set} else ${setDflt}`;
+    })
+    .join(' ');
+  return `(function(){ const ${tmp} = ${literal}; ${adds}${recordLoop} return ${tmp}; })()`;
+}
+
+// The value dispatch shared by declared properties and the record loop. A
+// value is copyable only when the emitter can name everything that may live
+// under it: a primitive holds nothing, an object with declared properties or
+// a record schema is rebuilt the same way, an array of primitives has
+// nowhere to hide a key. A $ref, a composition or an untyped node could all
+// carry keys this code cannot see, and copying the reference would smuggle
+// them into a value that claims to be sanitised, so the caller declines the
+// whole clone instead.
+// Drop every schema-position `default` in a subtree, leaving data positions
+// (const, enum, examples) untouched. Used on a record's value schema, where
+// the runtime's useDefaults fills nothing.
+function stripDefaultsDeep(node) {
+  if (!node || typeof node !== 'object') return node;
+  if (Array.isArray(node)) return node.map(stripDefaultsDeep);
+  const out = {};
+  for (const k of Object.keys(node)) {
+    if (k === 'default') continue;
+    out[k] = _INLINE_DATA_KEYS.has(k) ? node[k] : stripDefaultsDeep(node[k]);
+  }
+  return out;
+}
+
+const _CLONE_PRIMITIVE = new Set(['string', 'number', 'integer', 'boolean', 'null']);
+function emitValueExpr(prop, read, depth) {
+  if (!prop || typeof prop !== 'object') return null;
+  if (prop.$ref) return null;
+  const types = Array.isArray(prop.type) ? prop.type : [prop.type];
+  if (types.every((t) => _CLONE_PRIMITIVE.has(t))) return read;
+  const isRecordable = (s) => s.properties ||
+    (s.additionalProperties && typeof s.additionalProperties === 'object');
+  if (prop.type === 'object' && isRecordable(prop)) {
+    return emitClone(prop, read, depth + 1);
+  }
+  if (prop.type === 'array' && prop.items && typeof prop.items === 'object' &&
+      !Array.isArray(prop.items)) {
+    const it = prop.items;
+    const itemTypes = Array.isArray(it.type) ? it.type : [it.type];
+    if (itemTypes.every((t) => _CLONE_PRIMITIVE.has(t))) return read;
+    if (it.type === 'object' && isRecordable(it)) {
+      const el = '_e' + depth;
+      const inner = emitClone(it, el, depth + 1);
+      if (!inner) return null;
+      return `${read}.map((${el}) => (${inner}))`;
+    }
+  }
+  return null;
+}
+
+// The copy as an expression over `data`, or null where the kept key set is
+// not provable.
+function cloneExprFor(schema) {
+  if (!schema || typeof schema !== 'object') return null;
+  return emitClone(inlineRefsForClone(schema), 'data', 0);
+}
+
+module.exports = { cloneExprFor, emitClone, inlineRefsForClone, stripDefaultsDeep, resolveLocalPointer };

package/lib/interpreter.js

@@ -230,7 +230,7 @@ function cpAtMost(s, max) {
 function typeMatches(type, d) {
   switch (type) {
     case 'string': return typeof d === 'string';
-    case 'number': return typeof d === 'number' && isFinite(d);
+    case 'number': return Number.isFinite(d);
     case 'integer': return typeof d === 'number' && Number.isInteger(d);
     case 'boolean': return typeof d === 'boolean';
     case 'null': return d === null;
@@ -529,7 +529,7 @@ function evalLeafV(P, data) {
     if (!found) return false;
   }
   if (P.hasConst && !deepEqual(P.const, data)) return false;
-  if (P.hasNumber && typeof data === 'number' && isFinite(data)) {
+  if (P.hasNumber && Number.isFinite(data)) {
     if (P.minimum !== undefined && !(data >= P.minimum)) return false;
     if (P.maximum !== undefined && !(data <= P.maximum)) return false;
     if (P.exclusiveMinimum !== undefined && !(data > P.exclusiveMinimum)) return false;
@@ -646,7 +646,7 @@ function evalLeaf(P, data, errors, instancePath, schemaPath) {
     if (errors !== NOERRORS) errors.push(err('const', 'const', instancePath, schemaPath + '/const', { allowedValue: P.const }, 'must be equal to constant'));
     valid = false;
   }
-  if (P.hasNumber && typeof data === 'number' && isFinite(data)) {
+  if (P.hasNumber && Number.isFinite(data)) {
     if (P.minimum !== undefined && !(data >= P.minimum)) { errors === NOERRORS || errors.push(err('minimum', 'minimum', instancePath, schemaPath + '/minimum', { comparison: '>=', limit: P.minimum }, `must be >= ${P.minimum}`)); valid = false; }
     if (P.maximum !== undefined && !(data <= P.maximum)) { errors === NOERRORS || errors.push(err('maximum', 'maximum', instancePath, schemaPath + '/maximum', { comparison: '<=', limit: P.maximum }, `must be <= ${P.maximum}`)); valid = false; }
     if (P.exclusiveMinimum !== undefined && !(data > P.exclusiveMinimum)) { errors === NOERRORS || errors.push(err('exclusiveMinimum', 'exclusiveMinimum', instancePath, schemaPath + '/exclusiveMinimum', { comparison: '>', limit: P.exclusiveMinimum }, `must be > ${P.exclusiveMinimum}`)); valid = false; }
@@ -937,7 +937,7 @@ class Interpreter {
     }
 
     // numbers
-    if (P.hasNumber && typeof data === 'number' && isFinite(data)) {
+    if (P.hasNumber && Number.isFinite(data)) {
       if (P.minimum !== undefined && !(data >= P.minimum)) { errors === NOERRORS || errors.push(err('minimum', 'minimum', instancePath, schemaPath + '/minimum', { comparison: '>=', limit: P.minimum }, `must be >= ${P.minimum}`)); valid = false; }
       if (P.maximum !== undefined && !(data <= P.maximum)) { errors === NOERRORS || errors.push(err('maximum', 'maximum', instancePath, schemaPath + '/maximum', { comparison: '<=', limit: P.maximum }, `must be <= ${P.maximum}`)); valid = false; }
       if (P.exclusiveMinimum !== undefined && !(data > P.exclusiveMinimum)) { errors === NOERRORS || errors.push(err('exclusiveMinimum', 'exclusiveMinimum', instancePath, schemaPath + '/exclusiveMinimum', { comparison: '>', limit: P.exclusiveMinimum }, `must be > ${P.exclusiveMinimum}`)); valid = false; }

package/lib/js-compiler.js

@@ -489,24 +489,24 @@ function compileToJS(schema, defs, schemaMap) {
   // answer differently for it.
   if (schema.minimum !== undefined) {
     const min = schema.minimum
-    checks.push((d) => typeof d !== 'number' || !isFinite(d) || d >= min)
+    checks.push((d) => !Number.isFinite(d) || d >= min)
   }
   if (schema.maximum !== undefined) {
     const max = schema.maximum
-    checks.push((d) => typeof d !== 'number' || !isFinite(d) || d <= max)
+    checks.push((d) => !Number.isFinite(d) || d <= max)
   }
   if (schema.exclusiveMinimum !== undefined) {
     const min = schema.exclusiveMinimum
-    checks.push((d) => typeof d !== 'number' || !isFinite(d) || d > min)
+    checks.push((d) => !Number.isFinite(d) || d > min)
   }
   if (schema.exclusiveMaximum !== undefined) {
     const max = schema.exclusiveMaximum
-    checks.push((d) => typeof d !== 'number' || !isFinite(d) || d < max)
+    checks.push((d) => !Number.isFinite(d) || d < max)
   }
   if (schema.multipleOf !== undefined) {
     const div = schema.multipleOf
     checks.push((d) => {
-      if (typeof d !== 'number' || !isFinite(d)) return true
+      if (!Number.isFinite(d)) return true
       if (div === 0) return false
       const q = d / div
       return Number.isInteger(q) || Math.abs(q - Math.round(q)) < 1e-9
@@ -850,7 +850,7 @@ function multipleOfBad(v, m) {
 
 const TYPE_CHECKS = {
   string: (d) => typeof d === 'string',
-  number: (d) => typeof d === 'number' && isFinite(d),
+  number: (d) => Number.isFinite(d),
   integer: (d) => Number.isInteger(d),
   boolean: (d) => typeof d === 'boolean',
   null: (d) => d === null,
@@ -918,8 +918,15 @@ const PROTO_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '_
 // 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)}' +
+//
+// `__proto__` is read through the accessor on Object.prototype, which Deno
+// removes. There every read came back undefined, every object took the per-key
+// hasOwnProperty path, and a ten-field check went from 2.5 to 40 ns. Where the
+// accessor is missing the prototype comes from Object.getPrototypeOf instead,
+// chosen by a constant the engine folds, so Node pays nothing for the branch.
+const OWN_HELPERS = 'const _PN=({}).__proto__===Object.prototype;' +
+  'const _hop=Object.prototype.hasOwnProperty;function _h(o,k){return _hop.call(o,k)}' +
+  'function _ok(o,k){return (_PN?o.__proto__:Object.getPrototypeOf(o))===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
@@ -928,6 +935,11 @@ const OWN_HELPERS = 'const _hop=Object.prototype.hasOwnProperty;function _h(o,k)
 // 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.
+// Whether `v`, already known to be an object, has Object.prototype as its
+// prototype, read without depending on the __proto__ accessor. Needs OWN_HELPERS.
+function protoIs (v) {
+  return `((_PN?${v}.__proto__:Object.getPrototypeOf(${v}))===Object.prototype)`
+}
 function ownKeyExpr (ctx, v, key) {
   hoistOnce(ctx, '_ownHoisted', OWN_HELPERS)
   const k = JSON.stringify(key)
@@ -957,7 +969,8 @@ function withPlain (schema, v, lines, ctx, 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 decl = `const ${name}=typeof ${v}==='object'&&${v}!==null&&${protoIs(v)}`
+  lines.push(decl)
   const prev = ctx.plainOf.get(v)
   ctx.plainOf.set(v, name)
   try {
@@ -970,14 +983,15 @@ function withPlain (schema, v, lines, ctx, run) {
     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)
+    if (!used && lines[at] === decl) lines.splice(at, 1)
   }
 }
 // The same test at run time, for the closure compiler.
 const _hop = Object.prototype.hasOwnProperty
+const _PN = ({}).__proto__ === Object.prototype
 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))
+  return key in d && ((_PN ? d.__proto__ : Object.getPrototypeOf(d)) === Object.prototype || _hop.call(d, key))
 }
 
 const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'toString', 'valueOf',
@@ -2005,7 +2019,7 @@ function tryGenCombined(schema, access, ctx) {
   }
 
   if (t === 'number') {
-    const conds = [`typeof _v!=='number'||!isFinite(_v)`]
+    const conds = [`!Number.isFinite(_v)`]
     if (schema.minimum !== undefined) conds.push(`_v<${schema.minimum}`)
     if (schema.maximum !== undefined) conds.push(`_v>${schema.maximum}`)
     if (schema.exclusiveMinimum !== undefined) conds.push(`_v<=${schema.exclusiveMinimum}`)
@@ -2190,7 +2204,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
           case 'object': lines.push(`if(typeof ${v}!=='object'||${v}===null||Array.isArray(${v}))return false`); break
           case 'array': lines.push(`if(!Array.isArray(${v}))return false`); break
           case 'string': lines.push(`if(typeof ${v}!=='string')return false`); break
-          case 'number': lines.push(`if(typeof ${v}!=='number'||!isFinite(${v}))return false`); break
+          case 'number': lines.push(`if(!Number.isFinite(${v}))return false`); break
           case 'integer': lines.push(`if(!Number.isInteger(${v}))return false`); break
           case 'boolean': lines.push(`if(typeof ${v}!=='boolean')return false`); break
           case 'null': lines.push(`if(${v}!==null)return false`); break
@@ -2201,7 +2215,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
             case 'object': return `(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
             case 'array': return `Array.isArray(${v})`
             case 'string': return `typeof ${v}==='string'`
-            case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
+            case 'number': return `Number.isFinite(${v})`
             case 'integer': return `Number.isInteger(${v})`
             case 'boolean': return `typeof ${v}==='boolean'`
             case 'null': return `${v}===null`
@@ -2270,7 +2284,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
       // 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`)
+      lines.push(`if(!${protoIs(v)}&&!_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)}`)
@@ -2308,7 +2322,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   // non-finite value through: it carries no type, an empty schema accepts it,
   // and the interpreted engine reads it the same way. With `type: number` the
   // type check has already turned it away, so the guard is only needed here.
-  const numGuard = isNum ? '' : `typeof ${v}==='number'&&isFinite(${v})&&`
+  const numGuard = isNum ? '' : `Number.isFinite(${v})&&`
   if (schema.minimum !== undefined) lines.push(`if(${numGuard}${v}<${schema.minimum})return false`)
   if (schema.maximum !== undefined) lines.push(`if(${numGuard}${v}>${schema.maximum})return false`)
   if (schema.exclusiveMinimum !== undefined) lines.push(`if(${numGuard}${v}<=${schema.exclusiveMinimum})return false`)
@@ -3973,7 +3987,7 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         case 'object': return `(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
         case 'array': return `Array.isArray(${v})`
         case 'string': return `typeof ${v}==='string'`
-        case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
+        case 'number': return `Number.isFinite(${v})`
         case 'integer': return `Number.isInteger(${v})`
         case 'boolean': return `typeof ${v}==='boolean'`
         case 'null': return `${v}===null`
@@ -4710,7 +4724,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         case 'object': return `(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
         case 'array': return `Array.isArray(${v})`
         case 'string': return `typeof ${v}==='string'`
-        case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
+        case 'number': return `Number.isFinite(${v})`
         case 'integer': return `Number.isInteger(${v})`
         case 'boolean': return `typeof ${v}==='boolean'`
         case 'null': return `${v}===null`
@@ -4906,6 +4920,21 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       const allowed = propKeys.map(k => JSON.stringify(k)).join(',')
       body = `const _a${ci}=new Set([${allowed}]);let _x${ci}=0;for(const _f${ci} in ${v}){if(!_a${ci}.has(_f${ci})){_x${ci}=1;break}}if(_x${ci}){${detail(`!_a${ci}.has(_k${ci}[_i])`)}}`
     }
+    // When every declared property is required, a clean object has exactly the
+    // declared keys: if the enumerated count equals the declared count and
+    // every declared name is there, the enumerated set is the declared set and
+    // nothing is extra. That is the verdict generator's count, and it skips
+    // comparing each key against every name, which kept this function over
+    // twice the verdict's cost on an accepted document. Anything else, a
+    // different count or a missing name, falls through to the scan, which
+    // names the extra keys. A name Object.prototype carries answers `in`
+    // through the prototype without being enumerated, so those stay on the
+    // scan.
+    const req = new Set(Array.isArray(schema.required) ? schema.required : [])
+    if (propKeys.length > 0 && propKeys.every((k) => req.has(k) && !PROTO_NAMES.has(k))) {
+      const present = propKeys.map((k) => `${JSON.stringify(k)} in ${v}`).join('&&')
+      body = `let _n${ci}=0;for(const _f${ci} in ${v})_n${ci}++;if(_n${ci}!==${propKeys.length}||!(${present})){${body}}`
+    }
     lines.push(isObj
       ? `{${body}}`
       : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${body}}`)

package/lib/plan-compiler.js

@@ -182,7 +182,7 @@ function install(deps) {
       // no type bit, and an empty schema accepts it. So the numeric keywords
       // must not apply to it either, or `{ minimum: 3 }` rejects a value that
       // `{}` accepts and the compiled engine admits.
-      if (run !== null) checks.push((data) => typeof data !== 'number' || !isFinite(data) || run(data));
+      if (run !== null) checks.push((data) => !Number.isFinite(data) || run(data));
     }
     if (P.hasString) {
       const strs = [];

package/lib/plan-source.js

@@ -28,7 +28,7 @@ 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));
+  return x === null || typeof x === 'string' || typeof x === 'boolean' || Number.isFinite(x);
 }
 
 function lit(x) {
@@ -58,7 +58,7 @@ function local(ctx) {
 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}))`);
+  if (mask & T_NUMBER) parts.push(`Number.isFinite(${v})`);
   else if (mask & T_INTEGER) parts.push(`Number.isInteger(${v})`);
   if (mask & T_BOOLEAN) parts.push(`typeof ${v}==='boolean'`);
   if (mask & T_NULL) parts.push(`${v}===null`);
@@ -114,7 +114,7 @@ function emitLeaf(ctx, P, v, known) {
     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);
+    out += guarded(known, K_NUM, `Number.isFinite(${v})`, n);
   }
   if (P.hasString) {
     let s = '';

package/lib/tier0.js

@@ -46,6 +46,8 @@ const F_MULT = 16;
 // itself; see ownKeyExpr in js-compiler.js.
 const PROTO_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '__proto__']);
 const _hop = Object.prototype.hasOwnProperty;
+// Deno removes the __proto__ accessor; read the prototype another way there.
+const _PN = ({}).__proto__ === Object.prototype;
 
 function primConstraint(key, propSchema) {
   const t = propSchema.type;
@@ -137,7 +139,7 @@ function checkPrimitive(c, v) {
       if ((f & F_MULT) && !_multipleOk(v, c.multipleOf)) return false;
     }
   } else if (m === T_NUMBER) {
-    if (typeof v !== 'number' || !isFinite(v)) return false;
+    if (!Number.isFinite(v)) return false;
     const f = c.numFlags;
     if (f !== 0) {
       if ((f & F_MIN) && v < c.min) return false;
@@ -169,7 +171,7 @@ function tier0ValidateObject(plan, data) {
     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 && (c.protoName || (_PN ? data.__proto__ : Object.getPrototypeOf(data)) !== Object.prototype) && !_hop.call(data, c.key)) v = undefined;
     if (v === undefined) {
       if (reqMask & (1 << i)) return false;
       continue;
@@ -194,7 +196,7 @@ function tier0ValidateObject(plan, data) {
         if ((f & F_MULT) && !_multipleOk(v, c.multipleOf)) return false;
       }
     } else if (m === T_NUMBER) {
-      if (typeof v !== 'number' || !isFinite(v)) return false;
+      if (!Number.isFinite(v)) return false;
       const f = c.numFlags;
       if (f !== 0) {
         if ((f & F_MIN) && v < c.min) return false;

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.31.3",
+  "version": "1.32.1",
   "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_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",
+    "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_proto_accessor.js && node tests/test_plan_source.js && node tests/test_fused_remove_additional.js && node tests/test_runtime_parse.js && node tests/test_formats_single_pass.js && node tests/test_email_format_cost.js && node tests/test_format_single_error.js && node tests/test_defs_pointer_alias.js && node tests/test_cross_doc_root_ref.js && node tests/test_codegen_entrypoint_agreement.js && node tests/test_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.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"
+    "@ata-validator/native-darwin-arm64": "1.32.1",
+    "@ata-validator/native-darwin-x64": "1.32.1",
+    "@ata-validator/native-linux-arm64-gnu": "1.32.1",
+    "@ata-validator/native-linux-arm64-musl": "1.32.1",
+    "@ata-validator/native-linux-x64-gnu": "1.32.1",
+    "@ata-validator/native-linux-x64-musl": "1.32.1",
+    "@ata-validator/native-win32-x64": "1.32.1"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"