ata-validator 1.63.0 → 1.63.2

package/bin/ata.js

@@ -1,6 +1,10 @@
 #!/usr/bin/env node
 'use strict';
 const { env } = require('../lib/env');
+// Text that comes from a schema file (a $ref, a keyword name in a warning) is
+// written with its control characters as escapes, as `ata validate` writes
+// it: a schema could otherwise clear the screen or forge an `ata:` line.
+const term = (t) => require('../lib/diagnose').term(String(t));
 
 const fs = require('fs');
 const path = require('path');
@@ -299,7 +303,7 @@ function cmdCompile(args) {
       for (const w of compileWarnings) reportCompileError(input, w);
       process.exit(1);
     }
-    for (const w of compileWarnings) process.stderr.write(`ata: warning: ${input}: ${w}\n`);
+    for (const w of compileWarnings) process.stderr.write(`ata: warning: ${input}: ${term(w)}\n`);
   }
   if (!src) {
     reportCompileError(input, 'schema is too complex for standalone compilation');
@@ -397,7 +401,7 @@ function cmdBuild(args) {
     for (const c of report.compiled) {
       process.stdout.write(`ata: ${c.input} -> ${c.output} (${c.bytes.toLocaleString()} bytes${c.errors === 'compact' ? ', shared errors' : c.errors === 'schema' ? ', schema module' : ''})\n`);
       for (const t of (report.bunTargets || []).filter((t) => t.input === c.input)) process.stdout.write(`ata: bun target -> ${t.output} (for bun build --compile --aot)\n`);
-      for (const d of (report.bunDeclined || []).filter((d) => d.input === c.input)) process.stderr.write(`ata: warning: ${d.input}: ${d.reason}\n`);
+      for (const d of (report.bunDeclined || []).filter((d) => d.input === c.input)) process.stderr.write(`ata: warning: ${d.input}: ${term(d.reason)}\n`);
     }
     if (report.runtime) {
       process.stdout.write(`ata: error runtime -> ${report.runtime.output} (${report.runtime.bytes.toLocaleString()} bytes, shared by the modules above)\n`);
@@ -412,7 +416,7 @@ function cmdBuild(args) {
         noDetail++;
         process.stderr.write(`ata: warning ${w.input}: no error detail, failures report the single ATA9000 error (the verdict is exact)\n`);
       } else {
-        process.stderr.write(`ata: warning ${w.input}: ${w.warning}\n`);
+        process.stderr.write(`ata: warning ${w.input}: ${term(w.warning)}\n`);
       }
     }
     if (noDetail > 0 && args.opts.mode !== 'schema') {
@@ -422,7 +426,7 @@ function cmdBuild(args) {
       process.stdout.write(`ata: cached  ${c.input}\n`);
     }
     for (const s of report.skipped) {
-      process.stdout.write(`ata: skipped ${s.input}: ${s.reason}\n`);
+      process.stdout.write(`ata: skipped ${s.input}: ${term(s.reason)}\n`);
     }
     for (const f of report.failed) {
       reportCompileError(f.input, f.error);

package/lib/interpreter-core.js

@@ -247,6 +247,7 @@ function enumMember(P, data) {
 // JSON equality: the same function the code generator emits as `_deq`, so the
 // engines agree on what equal means (an object's own keys, in any order).
 const deepEqual = _deq;
+const propEnum = Object.prototype.propertyIsEnumerable;
 
 function codePointLength(s) {
   let n = 0;
@@ -369,6 +370,60 @@ function isObjectMap(v) {
 // per section so eval() can skip whole blocks without touching the schema
 // object. Plans have a fixed shape, which keeps eval() monomorphic where the
 // raw schema objects are not.
+// The keyword values of a schema node, from one pass over its enumerable
+// names (its own, as JSON gives them), in a record of one shape for link().
+const KEYWORD_RECORD = () => ({ '$ref': undefined, '$dynamicRef': undefined, type: undefined, enum: undefined, const: undefined, minimum: undefined, maximum: undefined, exclusiveMinimum: undefined, exclusiveMaximum: undefined, multipleOf: undefined, minLength: undefined, maxLength: undefined, pattern: undefined, format: undefined, minItems: undefined, maxItems: undefined, uniqueItems: undefined, prefixItems: undefined, items: undefined, contains: undefined, minContains: undefined, maxContains: undefined, required: undefined, minProperties: undefined, maxProperties: undefined, dependentRequired: undefined, propertyNames: undefined, properties: undefined, patternProperties: undefined, additionalProperties: undefined, dependentSchemas: undefined, propertyDependencies: undefined, allOf: undefined, anyOf: undefined, oneOf: undefined, not: undefined, if: undefined, then: undefined, else: undefined, unevaluatedProperties: undefined, unevaluatedItems: undefined });
+function readKeywords (schema) {
+  const S = KEYWORD_RECORD();
+  for (const k in schema) {
+    const v = schema[k];
+    switch (k) {
+      case '$ref': S['$ref'] = v; break;
+      case '$dynamicRef': S['$dynamicRef'] = v; break;
+      case 'type': S.type = v; break;
+      case 'enum': S.enum = v; break;
+      case 'const': S.const = v; break;
+      case 'minimum': S.minimum = v; break;
+      case 'maximum': S.maximum = v; break;
+      case 'exclusiveMinimum': S.exclusiveMinimum = v; break;
+      case 'exclusiveMaximum': S.exclusiveMaximum = v; break;
+      case 'multipleOf': S.multipleOf = v; break;
+      case 'minLength': S.minLength = v; break;
+      case 'maxLength': S.maxLength = v; break;
+      case 'pattern': S.pattern = v; break;
+      case 'format': S.format = v; break;
+      case 'minItems': S.minItems = v; break;
+      case 'maxItems': S.maxItems = v; break;
+      case 'uniqueItems': S.uniqueItems = v; break;
+      case 'prefixItems': S.prefixItems = v; break;
+      case 'items': S.items = v; break;
+      case 'contains': S.contains = v; break;
+      case 'minContains': S.minContains = v; break;
+      case 'maxContains': S.maxContains = v; break;
+      case 'required': S.required = v; break;
+      case 'minProperties': S.minProperties = v; break;
+      case 'maxProperties': S.maxProperties = v; break;
+      case 'dependentRequired': S.dependentRequired = v; break;
+      case 'propertyNames': S.propertyNames = v; break;
+      case 'properties': S.properties = v; break;
+      case 'patternProperties': S.patternProperties = v; break;
+      case 'additionalProperties': S.additionalProperties = v; break;
+      case 'dependentSchemas': S.dependentSchemas = v; break;
+      case 'propertyDependencies': S.propertyDependencies = v; break;
+      case 'allOf': S.allOf = v; break;
+      case 'anyOf': S.anyOf = v; break;
+      case 'oneOf': S.oneOf = v; break;
+      case 'not': S.not = v; break;
+      case 'if': S.if = v; break;
+      case 'then': S.then = v; break;
+      case 'else': S.else = v; break;
+      case 'unevaluatedProperties': S.unevaluatedProperties = v; break;
+      case 'unevaluatedItems': S.unevaluatedItems = v; break;
+    }
+  }
+  return S;
+}
+
 class Plan {
   // The plan is registered in the cache before `link` runs, so a schema
   // object that contains itself structurally resolves to the same plan
@@ -379,6 +434,13 @@ class Plan {
 
   link(interp) {
     const schema = this.schema;
+    // The keywords read once, by one pass over the schema's own names, into
+    // a record of one shape: read by name on the schema, each absent keyword
+    // was a lookup that missed on an object of yet another shape, and with
+    // many schemas in a process the 41 reads cost 3.7 us a node against 8 ns
+    // for the pass (measured on 64 shapes). Reads on the record hit one
+    // shape every time.
+    const S = readKeywords(schema);
     // Children are linked as plans (or booleans) up front, so a visit never
     // goes back through the plan cache. Reference targets are resolved at
     // evaluation time and cached per base URI.
@@ -387,21 +449,21 @@ class Plan {
     this.refBase0 = undefined;
     this.refRes0 = null;
     this.dynCache = null;
-    this.ref = typeof schema.$ref === 'string' ? schema.$ref : null;
-    this.dynamicRef = typeof schema.$dynamicRef === 'string' ? schema.$dynamicRef : null;
+    this.ref = typeof S.$ref === 'string' ? S.$ref : null;
+    this.dynamicRef = typeof S.$dynamicRef === 'string' ? S.$dynamicRef : null;
     this.tracked = this.ref !== null || this.dynamicRef !== null;
 
     this.typeMask = 0;
     this.typeNames = null;
-    if (schema.type !== undefined) {
-      const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+    if (S.type !== undefined) {
+      const types = Array.isArray(S.type) ? S.type : [S.type];
       let mask = 0;
       for (const t of types) mask |= typeBit(t);
       this.typeMask = mask;
       this.typeNames = types;
     }
-    this.hasType = schema.type !== undefined;
-    this.enum = schema.enum !== undefined ? schema.enum : null;
+    this.hasType = S.type !== undefined;
+    this.enum = S.enum !== undefined ? S.enum : null;
     // Membership for enumMember(): the primitive values in a Set, so a long
     // enum answers in one lookup, and the object and array values, which only
     // deepEqual can compare, in a list. Scanning every value with deepEqual
@@ -417,28 +479,28 @@ class Plan {
         else if (!(typeof v === 'number' && v !== v)) this.enumPrims.add(v);
       }
     }
-    this.hasConst = schema.const !== undefined;
-    this.const = schema.const;
-
-    this.minimum = typeof schema.minimum === 'number' ? schema.minimum : undefined;
-    this.maximum = typeof schema.maximum === 'number' ? schema.maximum : undefined;
-    this.exclusiveMinimum = typeof schema.exclusiveMinimum === 'number' ? schema.exclusiveMinimum : undefined;
-    this.exclusiveMaximum = typeof schema.exclusiveMaximum === 'number' ? schema.exclusiveMaximum : undefined;
-    this.multipleOf = typeof schema.multipleOf === 'number' ? schema.multipleOf : undefined;
+    this.hasConst = S.const !== undefined;
+    this.const = S.const;
+
+    this.minimum = typeof S.minimum === 'number' ? S.minimum : undefined;
+    this.maximum = typeof S.maximum === 'number' ? S.maximum : undefined;
+    this.exclusiveMinimum = typeof S.exclusiveMinimum === 'number' ? S.exclusiveMinimum : undefined;
+    this.exclusiveMaximum = typeof S.exclusiveMaximum === 'number' ? S.exclusiveMaximum : undefined;
+    this.multipleOf = typeof S.multipleOf === 'number' ? S.multipleOf : undefined;
     this.hasNumber = this.minimum !== undefined || this.maximum !== undefined || this.exclusiveMinimum !== undefined || this.exclusiveMaximum !== undefined || this.multipleOf !== undefined;
 
-    this.minLength = schema.minLength;
-    this.maxLength = schema.maxLength;
-    this.pattern = schema.pattern !== undefined ? interp.pattern(schema.pattern) : null;
-    this.patternSource = schema.pattern;
-    this.format = schema.format;
+    this.minLength = S.minLength;
+    this.maxLength = S.maxLength;
+    this.pattern = S.pattern !== undefined ? interp.pattern(S.pattern) : null;
+    this.patternSource = S.pattern;
+    this.format = S.format;
     this.formatFn = null;
-    if (schema.format !== undefined) {
+    if (S.format !== undefined) {
       // Own properties only, as the generated code reads them: an inherited
       // Object member ('hasOwnProperty', 'constructor') is not a check.
       const own = Object.prototype.hasOwnProperty;
       const uf = interp.userFormats;
-      const f = schema.format;
+      const f = S.format;
       const table = require('./formats').formatChecks();
       const fc = (uf && typeof f === 'string' && own.call(uf, f) && typeof uf[f] === 'function') ? uf[f]
         : (typeof f === 'string' && own.call(table, f) && typeof table[f] === 'function' ? table[f] : null);
@@ -448,31 +510,31 @@ class Plan {
     // A format compat registered for numbers (`type: 'number'`), checked on
     // numbers as the reference checks it.
     const nf = interp.numberFormats;
-    this.numFormatFn = schema.format !== undefined && nf !== null && typeof nf[schema.format] === 'function' ? nf[schema.format] : null;
+    this.numFormatFn = S.format !== undefined && nf !== null && typeof nf[S.format] === 'function' ? nf[S.format] : null;
     if (this.numFormatFn !== null) this.hasNumber = true;
 
-    this.minItems = schema.minItems;
-    this.maxItems = schema.maxItems;
-    this.uniqueItems = schema.uniqueItems === true;
-    this.prefixItems = Array.isArray(schema.prefixItems) ? schema.prefixItems.map(child) : null;
-    this.items = schema.items !== undefined ? child(schema.items) : undefined;
-    this.contains = schema.contains !== undefined ? child(schema.contains) : undefined;
-    this.minContains = schema.minContains;
-    this.maxContains = schema.maxContains;
+    this.minItems = S.minItems;
+    this.maxItems = S.maxItems;
+    this.uniqueItems = S.uniqueItems === true;
+    this.prefixItems = Array.isArray(S.prefixItems) ? S.prefixItems.map(child) : null;
+    this.items = S.items !== undefined ? child(S.items) : undefined;
+    this.contains = S.contains !== undefined ? child(S.contains) : undefined;
+    this.minContains = S.minContains;
+    this.maxContains = S.maxContains;
     this.hasArray = this.minItems !== undefined || this.maxItems !== undefined || this.uniqueItems || this.prefixItems !== null || this.items !== undefined || this.contains !== undefined;
 
-    this.required = Array.isArray(schema.required) ? schema.required : null;
-    this.minProperties = schema.minProperties;
-    this.maxProperties = schema.maxProperties;
-    this.dependentRequired = isObjectMap(schema.dependentRequired) ? Object.entries(schema.dependentRequired) : null;
-    this.propertyNames = schema.propertyNames !== undefined ? child(schema.propertyNames) : undefined;
+    this.required = Array.isArray(S.required) ? S.required : null;
+    this.minProperties = S.minProperties;
+    this.maxProperties = S.maxProperties;
+    this.dependentRequired = isObjectMap(S.dependentRequired) ? Object.entries(S.dependentRequired) : null;
+    this.propertyNames = S.propertyNames !== undefined ? child(S.propertyNames) : undefined;
     this.properties = null;
-    if (isObjectMap(schema.properties)) {
+    if (isObjectMap(S.properties)) {
       this.properties = new Map();
-      for (const key of Object.keys(schema.properties)) {
+      for (const key of Object.keys(S.properties)) {
         const ek = escapePointer(key);
         // Escaped once here; the walk only concatenates.
-        this.properties.set(key, { node: child(schema.properties[key]), seg: '/' + ek, schemaSeg: '/properties/' + ek });
+        this.properties.set(key, { node: child(S.properties[key]), seg: '/' + ek, schemaSeg: '/properties/' + ek });
       }
     }
     // A required key holding undefined is missing. Where the key is also a
@@ -491,26 +553,26 @@ class Plan {
       }
     }
     this.patternProperties = null;
-    if (isObjectMap(schema.patternProperties)) {
-      this.patternProperties = Object.keys(schema.patternProperties).map((src) => ({ src, re: interp.pattern(src), node: child(schema.patternProperties[src]) }));
+    if (isObjectMap(S.patternProperties)) {
+      this.patternProperties = Object.keys(S.patternProperties).map((src) => ({ src, re: interp.pattern(src), node: child(S.patternProperties[src]) }));
     }
-    this.additionalProperties = schema.additionalProperties !== undefined ? child(schema.additionalProperties) : undefined;
-    this.dependentSchemas = isObjectMap(schema.dependentSchemas) ? Object.entries(schema.dependentSchemas).map(([k, v]) => [k, child(v)]) : null;
+    this.additionalProperties = S.additionalProperties !== undefined ? child(S.additionalProperties) : undefined;
+    this.dependentSchemas = isObjectMap(S.dependentSchemas) ? Object.entries(S.dependentSchemas).map(([k, v]) => [k, child(v)]) : null;
     this.propertyDependencies = null;
-    if (isObjectMap(schema.propertyDependencies)) {
-      this.propertyDependencies = Object.entries(schema.propertyDependencies)
+    if (isObjectMap(S.propertyDependencies)) {
+      this.propertyDependencies = Object.entries(S.propertyDependencies)
         .filter(([, choices]) => isObjectMap(choices))
         .map(([k, choices]) => [k, new Map(Object.keys(choices).map((v) => [v, child(choices[v])]))]);
     }
     this.hasObject = this.required !== null || this.minProperties !== undefined || this.maxProperties !== undefined || this.dependentRequired !== null || this.propertyNames !== undefined || this.properties !== null || this.patternProperties !== null || this.additionalProperties !== undefined || this.dependentSchemas !== null || this.propertyDependencies !== null;
 
-    this.allOf = Array.isArray(schema.allOf) ? schema.allOf.map(child) : null;
-    this.anyOf = Array.isArray(schema.anyOf) ? schema.anyOf.map(child) : null;
-    this.oneOf = Array.isArray(schema.oneOf) ? schema.oneOf.map(child) : null;
-    this.not = schema.not !== undefined ? child(schema.not) : undefined;
-    this.if = schema.if !== undefined ? child(schema.if) : undefined;
-    this.then = schema.then !== undefined ? child(schema.then) : undefined;
-    this.else = schema.else !== undefined ? child(schema.else) : undefined;
+    this.allOf = Array.isArray(S.allOf) ? S.allOf.map(child) : null;
+    this.anyOf = Array.isArray(S.anyOf) ? S.anyOf.map(child) : null;
+    this.oneOf = Array.isArray(S.oneOf) ? S.oneOf.map(child) : null;
+    this.not = S.not !== undefined ? child(S.not) : undefined;
+    this.if = S.if !== undefined ? child(S.if) : undefined;
+    this.then = S.then !== undefined ? child(S.then) : undefined;
+    this.else = S.else !== undefined ? child(S.else) : undefined;
     // Macro keywords: the schema the macro returns is applied in place, the
     // way the reference validator does it, so its errors carry the keyword's
     // path and the keyword adds an error of its own when that schema fails.
@@ -527,13 +589,13 @@ class Plan {
     }
     this.hasApplicators = this.allOf !== null || this.anyOf !== null || this.oneOf !== null || this.not !== undefined || this.if !== undefined || this.macros !== null;
 
-    this.unevaluatedProperties = schema.unevaluatedProperties !== undefined ? child(schema.unevaluatedProperties) : undefined;
-    this.unevaluatedItems = schema.unevaluatedItems !== undefined ? child(schema.unevaluatedItems) : undefined;
+    this.unevaluatedProperties = S.unevaluatedProperties !== undefined ? child(S.unevaluatedProperties) : undefined;
+    this.unevaluatedItems = S.unevaluatedItems !== undefined ? child(S.unevaluatedItems) : undefined;
     // A `false` here rejects the member outright, and the error belongs to this
     // keyword on this object, not to a boolean schema that happens to sit
     // under it. Recorded at compile time so the check below is one test.
-    this.unevaluatedPropertiesFalse = schema.unevaluatedProperties === false;
-    this.unevaluatedItemsFalse = schema.unevaluatedItems === false;
+    this.unevaluatedPropertiesFalse = S.unevaluatedProperties === false;
+    this.unevaluatedItemsFalse = S.unevaluatedItems === false;
     this.hasUnevaluated = this.unevaluatedProperties !== undefined || this.unevaluatedItems !== undefined;
 
     // Custom keywords present on this node, in schema order. Each op holds
@@ -1251,9 +1313,15 @@ class Interpreter {
       }
     }
 
-    // objects
+    // objects. The object's own names, enumerable or not: a declared
+    // property is read by name, as the generated code reads it, so one
+    // hidden under its name is checked; patternProperties, propertyNames
+    // and additionalProperties see the names for-in sees, as there too, and
+    // minProperties and maxProperties count those.
     if (P.hasObject && bits === T_OBJECT) {
-      const keys = Object.keys(data);
+      const keys = Object.getOwnPropertyNames(data);
+      let hidden = 0;
+      if (P.minProperties !== undefined || P.maxProperties !== undefined) for (let k = 0; k < keys.length; k++) if (!propEnum.call(data, keys[k])) hidden++;
       if (P.required !== null) {
         const req = P.required;
         for (let i = 0; i < req.length; i++) {
@@ -1261,8 +1329,8 @@ class Interpreter {
           if (!Object.hasOwn(data, key) || (P.requiredUndef !== null && P.requiredUndef[i] && data[key] === undefined)) { errors === NOERRORS || errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`)); valid = false; }
         }
       }
-      if (P.minProperties !== undefined && keys.length < P.minProperties) { errors === NOERRORS || errors.push(err('minProperties', 'minProperties', instancePath, schemaPath + '/minProperties', { limit: P.minProperties }, `must NOT have fewer than ${P.minProperties} properties`)); valid = false; }
-      if (P.maxProperties !== undefined && keys.length > P.maxProperties) { errors === NOERRORS || errors.push(err('maxProperties', 'maxProperties', instancePath, schemaPath + '/maxProperties', { limit: P.maxProperties }, `must NOT have more than ${P.maxProperties} properties`)); valid = false; }
+      if (P.minProperties !== undefined && keys.length - hidden < P.minProperties) { errors === NOERRORS || errors.push(err('minProperties', 'minProperties', instancePath, schemaPath + '/minProperties', { limit: P.minProperties }, `must NOT have fewer than ${P.minProperties} properties`)); valid = false; }
+      if (P.maxProperties !== undefined && keys.length - hidden > P.maxProperties) { errors === NOERRORS || errors.push(err('maxProperties', 'maxProperties', instancePath, schemaPath + '/maxProperties', { limit: P.maxProperties }, `must NOT have more than ${P.maxProperties} properties`)); valid = false; }
       if (P.dependentRequired !== null) {
         for (const [key, deps] of P.dependentRequired) {
           if (Object.hasOwn(data, key)) {
@@ -1274,6 +1342,7 @@ class Interpreter {
       }
       if (P.propertyNames !== undefined) {
         for (const key of keys) {
+          if (!propEnum.call(data, key)) continue;
           if (!this.eval(P.propertyNames, key, base, dynScope, errors, instancePath, E ? schemaPath + '/propertyNames' : '', stack, DISCARD)) valid = false;
         }
       }
@@ -1283,6 +1352,7 @@ class Interpreter {
         const key = keys[k];
         let evaluated = false;
         const prop = props !== null ? props.get(key) : undefined;
+        const seen = prop !== undefined && patterns === null && P.additionalProperties === undefined || propEnum.call(data, key);
         if (prop !== undefined) {
           // A declared property whose value is undefined is not checked, as the
           // generated code does not check it: no JSON document carries one, and
@@ -1294,7 +1364,7 @@ class Interpreter {
           } else if (P.requiredInProps !== null && P.requiredInProps.has(key)) { errors === NOERRORS || errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`)); valid = false; }
           evaluated = true;
         }
-        if (patterns !== null) {
+        if (patterns !== null && seen) {
           for (let pi = 0; pi < patterns.length; pi++) {
             const pp = patterns[pi];
             if (pp.re.test(key)) {
@@ -1303,7 +1373,7 @@ class Interpreter {
             }
           }
         }
-        if (!evaluated && P.additionalProperties !== undefined) {
+        if (!evaluated && seen && P.additionalProperties !== undefined) {
           // `additionalProperties: false` keeps its own keyword and names the
           // property it turned away. Running it as a plain false subschema
           // reported `not` at the key's path, which drops both.

package/lib/ir/emit.mjs

@@ -16,8 +16,16 @@ const FAST = {
   pattern: (n, x) => compilePatternInline(n, x),
   // A string has between length/2 and length code points, so the length
   // alone settles most cases and the count runs only near the bound.
-  minLength: (n, x) => `${x}.length>=${2 * n}||${x}.length>=${n}&&cpLen(${x})>=${n}`,
-  maxLength: (n, x) => `${x}.length<=${n}||${x}.length<=${2 * n}&&cpLen(${x})<=${n}`,
+  // The bound is written into the module as a number, so it has to be one: a
+  // schema that gave a string here had it written as source, and what the
+  // string said ran in whatever imported the module. Refused, as the closure
+  // writer refuses it.
+  minLength: (n, x) => { const b = bound(n, 'minLength'); return `${x}.length>=${2 * b}||${x}.length>=${b}&&cpLen(${x})>=${b}` },
+  maxLength: (n, x) => { const b = bound(n, 'maxLength'); return `${x}.length<=${b}||${x}.length<=${2 * b}&&cpLen(${x})<=${b}` },
+}
+function bound (n, k) {
+  if (typeof n !== 'number' || !Number.isFinite(n)) throw new Error(`ir: ${k} is not a number`)
+  return n
 }
 // enum and const with only primitive values need no deep equality: the
 // value is one of them exactly when it is === one of them (JSON numbers have
@@ -44,7 +52,14 @@ function inline (fn, vExpr, nExpr) {
 }
 
 // How many names an object must list before a module visits the object's own
-// names instead of looking each one up.
+// names instead of looking each one up. Measured on SchemaStore's samples,
+// warmed, against the compiled modules: from 16 names the geometric mean is
+// 0.878 with 23 schemas under half the time, from 32 it is 0.914 with 15,
+// from 64 0.941 with 8, and the count slower by a fifth is 47 at each. A
+// dense document under a short list (sil-kit, csslintrc: most of 16 to 38
+// names present) pays the walk's array and dispatch, 2 to 4x the direct
+// reads; a sparse one under a long list (putout, 475 names) would pay a
+// read per name, 100x the walk.
 const WALK_MIN = 16
 // Source characters past which a verdict body is its own function (the
 // verdict threshold of the current engine's generator, SPLIT_PROP_SCHEMA).
@@ -96,14 +111,90 @@ export function emitIR (ir, { from = 'ata-validator/kernels', verdict = false, f
     use(fn)
     return fn
   }
+  // An own-property test written in the module with the module's own
+  // reference to hasOwnProperty. The kernels' own() is one function for every
+  // module of a page, so its property lookup met the objects of every schema
+  // and stopped being cached for any (rc3-environment alone 1.0x the compiled
+  // module, beside 438 other schemas 2.1x).
+  let HOP = null
+  const ownSrc = (o, k) => {
+    if (HOP === null) HOP = constOf('Object.prototype.hasOwnProperty')
+    return `${HOP}.call(${o},${k})`
+  }
+  // A small verdict written in at its call, as the compiled modules write a
+  // referenced schema in at each property: every copy keeps its own record of
+  // the shapes it meets, where one function called from forty places met all
+  // of them and V8 stopped inlining it (coffeelint, 38 properties naming one
+  // definition). Only a verdict with no cycle through it, no guard and no
+  // dynamic scope, whose body is INLINE_BODY characters or fewer; a verdict
+  // body leaves only by `return false`, so it runs as a block. Its parameters
+  // are bound in the block: the value, and the empty paths and list of a
+  // verdict call.
+  const INLINE_BODY = 500
+  // Inlined source one function may take in all: past it a function grows
+  // beyond what V8 optimizes (putout's 475 properties, 0.01x the compiled
+  // module before, 1.08x with every call written in).
+  // 2000 left coffeelint's 38 names calling one 300-character check (2.2x
+  // the compiled module); 8000 inlines them and keeps putout's 475-name
+  // function optimizable (both measured on SchemaStore, warmed).
+  const INLINE_BUDGET = 8000
+  let inlineBudget = INLINE_BUDGET
+  const inlining = new Set()
+  const inlineBodies = new Map()
+  const inlineCall = (c) => {
+    if (c.proc === null || c.dynamic || c.guard || ir.dynamic || inlining.has(c.proc)) return null
+    const p = ir.procs.get(c.proc)
+    if (!p || p.mode !== 'verdict') return null
+    // Follow a verdict that is only a call of another (procName's alias).
+    const b = p.body.t === 'seq' && p.body.body.length === 1 ? p.body.body[0] : p.body
+    if (b.t === 'require' && b.e.t === 'pcall' && b.e.e === 'null' && !b.e.dynamic && !b.e.guard && b.e.x.t === 'var' && b.e.x.n === 'd' && b.e.proc !== c.proc) return inlineCall({ ...b.e, x: c.x })
+    // Each procedure is written once, with a full budget for what it
+    // inlines itself, and that text is its size: a site inlines it when the
+    // text fits the site's remaining budget. Written at every call site
+    // under the site's budget, the text depended on the order of the sites,
+    // and a definition too large under a deep nesting was rendered again
+    // for each site below each site (a suite schema took ten minutes).
+    let body = inlineBodies.get(c.proc)
+    if (body === undefined) {
+      inlining.add(c.proc); const saved = inlineBudget; inlineBudget = INLINE_BUDGET
+      try { body = stmt(p.body, true) } finally { inlining.delete(c.proc); inlineBudget = saved }
+      if (body.length > INLINE_BODY || /\breturn true\b/.test(body)) body = null
+      inlineBodies.set(c.proc, body)
+    }
+    if (body === null || body.length > inlineBudget) return null
+    inlineBudget -= body.length
+    const x = expr(c.x); const t = 'i' + (++inlineN)
+    return `{const ${t}=${x}\n{const d=${t},V=${t},e=null,P="",SP="",A=null\n${body}}}\n`
+  }
+  let inlineN = 0
+  // The verdict calls already made in the row of statements being written
+  // (seq), handed to a row nested directly in it.
+  let seqSeen = null
+  // The plain-prototype flags a fill has bound, by the object's expression.
+  const fillPlain = new Map()
   const procName = (id) => {
     if (emitted.has(id)) return emitted.get(id)
     const p = ir.procs.get(id)
+    // A verdict that is one call of another on its own value (a branch that
+    // is only a $ref) is that other verdict: no function of its own, and a
+    // caller that already ran it can see the repeat (seq).
+    if (p.mode === 'verdict' && !ir.dynamic) {
+      const b = p.body.t === 'seq' && p.body.body.length === 1 ? p.body.body[0] : p.body
+      if (b.t === 'require' && b.e.t === 'pcall' && b.e.e === 'null' && !b.e.dynamic && !b.e.guard && b.e.x.t === 'var' && b.e.x.n === 'd' && b.e.proc !== id) {
+        const to = procName(b.e.proc)
+        emitted.set(id, to)
+        return to
+      }
+    }
     const name = id
     emitted.set(id, name)
     const isVerdict = p.mode === 'verdict'
-    if (p.mode === 'fill') { fns.push(`function ${name}(d){\n${stmt(p.body, true)}}`); return name }
-    const body = stmt(p.body, isVerdict)
+    if (p.mode === 'fill') { fillPlain.clear(); fns.push(`function ${name}(d){\n${stmt(p.body, true)}}`); return name }
+    // Each function written gets its own budget of inlined source (inlineCall).
+    const savedBudget = inlineBudget
+    inlineBudget = INLINE_BUDGET
+    let body
+    try { body = stmt(p.body, isVerdict) } finally { inlineBudget = savedBudget }
     const head = p.mode === 'ann' ? 'if(A===null)A=newAnn()\n' : ''
     if (p.mode === 'ann') use('newAnn')
     const wrapped = ir.dynamic
@@ -213,7 +304,23 @@ export function emitIR (ir, { from = 'ata-validator/kernels', verdict = false, f
           const ap = walked && n.body.find((c) => c.t === 'if' && c.then.t === 'keys' && c.then.apClosed && c.then.obj.t === 'var' && c.then.obj.n === walked.then.x.n)
           if (ap) { skip = ap; folded.add(walked.then) }
         }
-        return n.body.filter((x) => x !== skip).map((x) => stmt(x, v)).join('')
+        // In a verdict the same check of the same value twice in a row of
+        // statements is once: the first returned false or passed, and a
+        // verdict has no side effects (custom keywords and formats, which
+        // could, are refused above). A schema that names one definition
+        // under both allOf and anyOf ran it twice per item (devinit).
+        // A row nested directly in a row runs unconditionally after what came
+        // before it, so it shares the set; anything under a condition, a
+        // loop or a let starts its own.
+        const seen = v ? (seqSeen || new Set()) : null
+        seqSeen = null
+        return n.body.filter((x) => x !== skip).map((x) => {
+          seqSeen = x.t === 'seq' ? seen : null
+          const t = stmt(x, v)
+          seqSeen = null
+          if (seen !== null && (x.t === 'require' || x.t === 'branches')) { if (seen.has(t)) return ''; seen.add(t) }
+          return t
+        }).join('')
       }
       // An object that lists many names: visit the object's own names, every
       // one enumerable or not (an entry checks its own presence, so a name it
@@ -235,7 +342,14 @@ export function emitIR (ir, { from = 'ata-validator/kernels', verdict = false, f
         const rows = n.keyed.map(([p, i]) => {
           const e = n.body[i]
           const c = v ? verdictCall(e) : null
-          if (c !== null) return { p, fn: procName(c.proc) }
+          if (c !== null) {
+            // A small check written in at its name (inlineCall), as the
+            // compiled modules write a referenced definition at each
+            // property: csslintrc's 31 names each called one enum check.
+            const t = inlineCall({ ...c, x: { t: 'var', n: 'y' } })
+            if (t !== null) return { p, inl: t }
+            return { p, fn: procName(c.proc) }
+          }
           if (v && e.t === 'let' && e.body.t === 'if' && !e.body.else && selfContained(e.body.then, e.name)) {
             const text = stmt(e.body.then, true)
             return { p, e, text, src: `{const ${e.name}=${expr(e.value)}\nif(${expr(e.body.c)}){\n${text}}}\n` }
@@ -248,7 +362,9 @@ export function emitIR (ir, { from = 'ata-validator/kernels', verdict = false, f
         const small = tabled.filter((r) => (sizes.get(r.fn) ?? Infinity) <= INLINE_MAX).length
         const useTable = tabled.length >= TABLE_MIN || (tabled.length >= WALK_MIN && small * 2 < tabled.length)
         const left = rows.filter((r) => !useTable || !r.fn)
-        const body = (r) => r.fn ? `{const y=${X}[${lit(r.p)}];if(y!==void 0&&!${r.fn}(y,null,s,"",y,"",null))return false}\n` : r.src
+        // In the walk a name comes from the object's own names, so its value
+        // is read without a presence test.
+        const body = (r) => r.fn ? `{const y=${X}[${lit(r.p)}];if(y!==void 0&&!${r.fn}(y,null,s,"",y,"",null))return false}\n` : r.inl ? `{const y=${X}[${lit(r.p)}];if(y!==void 0){${r.inl}}}\n` : r.src
         // A key is told from the names by its length first, a switch on an
         // integer the engine makes a jump table, and then compared with the
         // few names of that length: a switch on the names compared each key
@@ -265,9 +381,20 @@ export function emitIR (ir, { from = 'ata-validator/kernels', verdict = false, f
         const dispatch = (k) => `switch(${k}.length){\n${[...byLen].map(([l, rs]) => `case ${l}:${rs.map((r) => `if(${k}===${lit(r.p)}){\n${r.empty ? '' : body(r)}}`).join('else ')}${fold ? `else{${unknown}}` : ''}break\n`).join('')}${fold ? `default:${unknown}` : ''}}`
         // A name the table answers is listed; with the fold every other name
         // goes through the dispatch, which knows the listed ones.
-        if (!useTable) return `${always}{const ks=Object.getOwnPropertyNames(${X});for(let j=0;j<ks.length;j++){const k=ks[j];${dispatch('k')}}}\n`
-        const T = constOf(`new Map([${tabled.map((r) => `[${lit(r.p)},${r.fn}]`).join(',')}])`)
-        return `${always}{const ks=Object.getOwnPropertyNames(${X});for(let j=0;j<ks.length;j++){const k=ks[j],f=${T}.get(k);if(f!==void 0){const y=${X}[k];if(y!==void 0&&!f(y,null,s,"",y,"",null))return false}${left.length || fold ? `else ${dispatch('k')}` : ''}}}\n`
+        let walk
+        if (!useTable) walk = `for(let j=0;j<ks.length;j++){const k=ks[j];${dispatch('k')}}`
+        else {
+          const T = constOf(`new Map([${tabled.map((r) => `[${lit(r.p)},${r.fn}]`).join(',')}])`)
+          walk = `for(let j=0;j<ks.length;j++){const k=ks[j],f=${T}.get(k);if(f!==void 0){const y=${X}[k];if(y!==void 0&&!f(y,null,s,"",y,"",null))return false}${left.length || fold ? `else ${dispatch('k')}` : ''}}`
+        }
+        // A self-measuring switch to a direct read of each listed name on
+        // dense documents was tried here and taken out: it won on five
+        // config schemas (csslintrc, coffeelint, jshintrc) and lost as much
+        // on others (liquibase 0.27 to 1.46 of the compiled module, a
+        // 142-name object read in dictionary mode 8x slower than the walk),
+        // no rule from the measurements told the two apart, and its direct
+        // form once rejected {} through an inherited toString.
+        return `${always}{const ks=Object.getOwnPropertyNames(${X});${walk}}\n`
       }
       case 'if': {
         // A condition that is a call under annotations merges its collector.
@@ -302,6 +429,13 @@ export function emitIR (ir, { from = 'ata-validator/kernels', verdict = false, f
         // SchemaStore's slower by 6-80% when all of them run in one process.)
         const last = n.order === 'protoLast' && !v
         if (last) use('keysOf')
+        // A verdict walks the object's own names with for-in, no array, each
+        // name tested as the object's own: a name enumerable on
+        // Object.prototype is not one of them (tests/test_ir_module_split.mjs).
+        if (v) {
+          const o = expr(n.obj)
+          return `for(const ${n.k} in ${o}){if(!${ownSrc(o, n.k)})continue\n${stmt(n.body, v)}}\n`
+        }
         return `for(const ${n.k} of ${last ? 'keysOf' : 'Object.keys'}(${expr(n.obj)})){\n${stmt(n.body, v)}}\n`
       }
       case 'range': return `for(let ${n.i}=${typeof n.from === 'number' ? n.from : expr(n.from)};${n.i}<${expr(n.arr)}.length;${n.i}++){\n${stmt(n.body, v)}}\n`
@@ -315,30 +449,48 @@ export function emitIR (ir, { from = 'ata-validator/kernels', verdict = false, f
           use('newAnn', 'mergeAnn')
           return `{const a=newAnn(),c=e===null?0:e.length;if(${callOf(c, 'e', 'a')}&&(e===null||e.length===c))mergeAnn(A,a);else if(e===null)return false}\n`
         }
+        if (v && c.e === 'null') { const t = inlineCall(c); if (t !== null) return t }
         if (c.e === 'inherit') return v ? `if(!${callOf(c, 'null', 'null')})return false\n` : `if(!${callOf(c, 'e', 'null')}&&e===null)return false\n`
         return `if(!${callOf(c, 'null', 'null')})${v ? 'return false' : '{if(e===null)return false}'}\n`
       }
       case 'fail': return fail(n.err, v) + '\n'
       case 'branches': return branches(n, v)
       case 'setDefault': {
-        use('own')
         if (n.k === '__proto__') use('setOwn')
         const val = n.v
         let src
         if (typeof val !== 'object' || val === null) src = lit(val)
         else if (Array.isArray(val) && val.length === 0) src = '[]'
-        else { use('copyOf'); src = `copyOf(${constOf(lit(val))})` }
+        else {
+          // A small default written as a literal: a fresh value each time
+          // it is read, as the compiled modules write `{}`. copyOf's JSON
+          // round trip was 72% of revola's verdict and 39% of changepacks'.
+          // Not when a key in it is `__proto__`, which a literal would read
+          // as the prototype, nor a large one, which would swell the fill.
+          const text = lit(val)
+          if (text.length <= 400 && !text.includes('"__proto__"')) src = text
+          else { use('copyOf'); src = `copyOf(${constOf(text)})` }
+        }
         const o = expr(n.o)
         // A store under the name itself: through setOwn's computed key, V8
         // turned an object given more than a few defaults into a dictionary,
         // slow from then on for every reader (htmlhint's root, 23 defaults:
         // getOwnPropertyNames 10 to 999 ns). __proto__ needs defineProperty.
-        if (n.k === '__proto__') return `if(!own(${o},${lit(n.k)}))setOwn(${o},${lit(n.k)},${src})\n`
+        if (n.k === '__proto__') return `if(!${ownSrc(o, lit(n.k))})setOwn(${o},${lit(n.k)},${src})\n`
+        // A defined value under the name on an ordinary object is the
+        // object's own: the own test runs only for an undefined read, or on
+        // an object with another prototype, as the current engine's fill
+        // reads it. The flag is bound once per object in the fill.
+        if (!(n.k in Object.prototype)) {
+          let pl = fillPlain.get(o); let bind = ''
+          if (pl === undefined) { pl = 'pl' + fillPlain.size; fillPlain.set(o, pl); bind = `const ${pl}=(PN?${o}.__proto__:Object.getPrototypeOf(${o}))===Object.prototype\n` }
+          return `${bind}if((${o}[${lit(n.k)}]===void 0||!${pl})&&!${ownSrc(o, lit(n.k))})${o}[${lit(n.k)}]=${src}\n`
+        }
         // A read or `in` before hasOwnProperty, as the current engine's fill
         // does, was measured both ways: faster where the defaults are mostly
         // present (jshintrc 1195 to 522 ns), slower where they are mostly
         // missing (prometheus 3671 to 4601). hasOwnProperty alone is kept.
-        return `if(!own(${o},${lit(n.k)}))${o}[${lit(n.k)}]=${src}\n`
+        return `if(!${ownSrc(o, lit(n.k))})${o}[${lit(n.k)}]=${src}\n`
       }
       case 'fcall': return `${procName(n.proc)}(${expr(n.x)})\n`
       case 'defaultsMask': {
@@ -371,6 +523,9 @@ export function emitIR (ir, { from = 'ata-validator/kernels', verdict = false, f
     const x = expr(n.x); const path = expr(n.path); const ev = expr(n.ev); const sps = n.sps.map(expr)
     if (v) {
       const calls = ps.map((p) => `${p}(${x},null,s,"",${ev},"",null)`)
+      // One branch passes exactly when it passes, for anyOf and oneOf: the
+      // form of a required call, so a repeat of it is seen (seq).
+      if (calls.length === 1) return `if(!${calls[0]})return false\n`
       return `if(${isAny ? `!(${calls.join('||')})` : `(${calls.map((c) => `(${c}?1:0)`).join('+')})!==1`})return false\n`
     }
     use('collapse')
@@ -412,7 +567,7 @@ export function emitIR (ir, { from = 'ata-validator/kernels', verdict = false, f
       case 'var': return n.n
       case 'get': return `${expr(n.o)}[${expr(n.k)}]`
       case 'field': return `${expr(n.o)}.${n.k}`
-      case 'own': use('own'); return `own(${expr(n.o)},${expr(n.k)})`
+      case 'own': return ownSrc(expr(n.o), expr(n.k))
       case 'not': return `!(${expr(n.e)})`
       case 'and': return `(${expr(n.a)}&&${expr(n.b)})`
       case 'or': return `(${expr(n.a)}||${expr(n.b)})`

package/lib/ir/front.mjs

@@ -332,6 +332,27 @@ function build (schema, { assertFormat = true, schemas = null, metaschemas = nul
     if (objKw && !knownObj) lets.push([o.n, { t: 'isObj', x }], [plain.n, and(o, { t: 'plainProto', x })])
     const keys = known !== null ? ['type', ...Object.keys(s).filter((k) => k !== 'type')] : Object.keys(s)
     const customOps = []
+    // A verdict with patternProperties beside additionalProperties: false
+    // walks the object's names once: each pattern tested once per name, a
+    // name no pattern matches and properties does not list fails. Two loops
+    // tested every pattern twice per name (minecraft-custom-main-menu-mod,
+    // 2.7x the compiled module). Errors keep the two loops: their order is
+    // the current engine's.
+    let patsFused = false
+    const fusedPats = () => {
+      const pats = s.patternProperties; const kv = vr(fresh('k')); const m = fresh('m')
+      const inner = []
+      for (const p in pats) {
+        const y = vr(fresh('x'))
+        const body = child(pats[p], y, catE(path, catE(lit('/'), { t: 'seg', k: kv })), cat(sp, '/patternProperties/' + seg(p)))
+        inner.push(iff({ t: 're', src: p, k: kv }, seq({ t: 'incr', name: m }, nop(body) ? null : { t: 'let', name: y.n, value: get(x, kv), body })))
+      }
+      const names = Object.keys(props)
+      inner.push(iff(and(cmp('===', vr(m), lit(0)), ...(names.length ? [not({ t: 'known', k: kv, names, pats: [] })] : []), has(null, kv)), { t: 'ret' }))
+      patsFused = true
+      return iff(o, { t: 'keys', obj: x, k: kv.n, order: 'keys', body: { t: 'count', name: m, body: seq(inner) } })
+    }
+    const canFuse = verdict && !ann && kw === null && s.additionalProperties === false && isObj(s.patternProperties)
     // Under ctx each keyword's statements go to its place in the current
     // engine's walk (lib/interpreter-core.js eval), not schema order.
     const buckets = ctx ? new Map() : null
@@ -399,6 +420,8 @@ function build (schema, { assertFormat = true, schemas = null, metaschemas = nul
         const closed = s.additionalProperties === false && !isObj(s.patternProperties) && !ann && kw === null ? Object.keys(props) : null
         if (inner.length) out.push(iff(o, { t: 'props', x, body: inner, keyed: ann || kw !== null ? null : keyed, closed }))
       } else if (k === 'patternProperties') {
+        if (patsFused) continue
+        if (canFuse) { out.push(fusedPats()); continue }
         const kv = vr(fresh('k'))
         const inner = []
         for (const p in n) {
@@ -417,6 +440,8 @@ function build (schema, { assertFormat = true, schemas = null, metaschemas = nul
         for (const a in n) inner.push(iff(own(x, lit(a)), seq(n[a].map((r) => iff(or(cmp('===', get(x, lit(r)), lit(undefined)), not(has(r, lit(r)))), fail(err('ATA7005', 'required', path, cat(sp, '/dependentRequired'), paramsOf(required.params(r)), lit(required.msg(r)), required.exp(r), required.rank, ev, required.detail, required.suggest)))))))
         out.push(iff(o, seq(inner)))
       } else if (k === 'additionalProperties') {
+        if (patsFused) continue
+        if (canFuse) { out.push(fusedPats()); continue }
         const known2 = Object.keys(s.properties || {})
         const pats = Object.keys(s.patternProperties || {})
         const kv = vr(fresh('k'))
@@ -611,8 +636,14 @@ function build (schema, { assertFormat = true, schemas = null, metaschemas = nul
       }
     }
     if (post !== null) out.push(post)
+    // A value nothing below reads is not computed: an item schema of a type
+    // alone read each array element's prototype for a flag no check used
+    // (bitrise-step, half its verdict).
+    const text = JSON.stringify(out)
+    for (const n of out) if (n.t === 'bind') n.names = n.names.filter(([name]) => text.includes('"n":' + JSON.stringify(name)))
+    out = out.filter((n) => n.t !== 'bind' || n.names.length)
     let body = seq(out)
-    for (let i = lets.length - 1; i >= 0; i--) body = { t: 'let', name: lets[i][0], value: lets[i][1], body }
+    for (let i = lets.length - 1; i >= 0; i--) if (text.includes('"n":' + JSON.stringify(lets[i][0]))) body = { t: 'let', name: lets[i][0], value: lets[i][1], body }
     return body
   }
 

package/lib/js-compiler-errors.js

@@ -1147,11 +1147,16 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const expected = types.join(', ')
     // As written: a one-element array stays an array, as the interpreted engine
     // reports it.
-    const expectedParam = !Array.isArray(schema.type) ? `'${types[0]}'` : JSON.stringify(types)
+    // Escaped like every other schema string written into this source: a
+    // type name is the schema author's text, and a quote in one that is not
+    // a JSON Schema type closed the literal and ran what followed as code,
+    // in the process that compiled the schema and in the module written
+    // from it.
+    const expectedParam = !Array.isArray(schema.type) ? `'${esc(String(types[0]))}'` : JSON.stringify(types)
     {
       const typeSp = `${schemaPrefix}/type`
       const lit = buildErrorLiteral({ keyword: 'type', schemaPath: typeSp, sourceMap: ctx.sourceMap })
-      lines.push(`if(!(${conds.join('||')})){_e.push({code:'${lit.codeStr}',keyword:'type',instancePath:${pathExpr||'""'},schemaPath:'${typeSp}'${ordinalField(ctx, `${typeSp}`)},params:{type:${expectedParam}},message:'must be ${expected}',docUrl:'${lit.docUrl}'${lit.frame}});if(!_all)return{valid:false,errors:_e}}`)
+      lines.push(`if(!(${conds.join('||')})){_e.push({code:'${lit.codeStr}',keyword:'type',instancePath:${pathExpr||'""'},schemaPath:'${typeSp}'${ordinalField(ctx, `${typeSp}`)},params:{type:${expectedParam}},message:'must be ${esc(expected)}',docUrl:'${lit.docUrl}'${lit.frame}});if(!_all)return{valid:false,errors:_e}}`)
     }
   }
 
@@ -2038,7 +2043,9 @@ TYPE_KEYWORDS.integer = TYPE_KEYWORDS.number
 const NOT_VALIDATING = new Set(['$schema', '$id', '$anchor', '$comment', '$defs', 'definitions', 'title', 'description', 'default', 'examples', 'deprecated', 'readOnly', 'writeOnly', '$vocabulary'])
 function typeMismatchRest(schema, types) {
   const drop = new Set(['type', 'enum', 'const', 'anyOf', 'oneOf'])
-  for (const t of types) for (const k of (TYPE_KEYWORDS[t] || [])) drop.add(k)
+  // Own names only: a type called `constructor` or `__proto__` read
+  // Object.prototype's member here and threw while compiling.
+  for (const t of types) if (Object.prototype.hasOwnProperty.call(TYPE_KEYWORDS, t)) for (const k of TYPE_KEYWORDS[t]) drop.add(k)
   // A built-in format is written for strings only (`typeof v==='string'&&`
   // off the string path), so for a value that failed `type: string` it can
   // never fire: carried here it was dead code in every module that checks one.
@@ -2435,11 +2442,16 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const expected = types.join(', ')
     // As written: a one-element array stays an array, as the interpreted engine
     // reports it.
-    const expectedParam = !Array.isArray(schema.type) ? `'${types[0]}'` : JSON.stringify(types)
+    // Escaped like every other schema string written into this source: a
+    // type name is the schema author's text, and a quote in one that is not
+    // a JSON Schema type closed the literal and ran what followed as code,
+    // in the process that compiled the schema and in the module written
+    // from it.
+    const expectedParam = !Array.isArray(schema.type) ? `'${esc(String(types[0]))}'` : JSON.stringify(types)
     // Type check: push error but continue — wrap remaining in type-success block
     const typeOk = `_tok${ctx.varCounter++}`
     lines.push(`const ${typeOk}=${conds.join('||')}`)
-    lines.push(`if(!${typeOk}){${fail('type', 'type', `{type:${expectedParam}}`, `'must be ${expected}'`)}}`)
+    lines.push(`if(!${typeOk}){${fail('type', 'type', `{type:${expectedParam}}`, `'must be ${esc(expected)}'`)}}`)
     // Subsequent optimized code runs inside if(typeOk){...}
     if (types.length === 1) {
       isObj = types[0] === 'object'

package/lib/js-compiler.js

@@ -832,9 +832,9 @@ function resolveRef(ref, defs, schemaMap) {
 
 function buildTypeCheck(types) {
   if (types.length === 1) {
-    return TYPE_CHECKS[types[0]] || (() => true)
+    return typeCheckOf(types[0]) || (() => true)
   }
-  const fns = types.map(t => TYPE_CHECKS[t]).filter(Boolean)
+  const fns = types.map(typeCheckOf).filter(Boolean)
   return (d) => {
     for (let i = 0; i < fns.length; i++) {
       if (fns[i](d)) return true
@@ -902,6 +902,10 @@ function multipleOfBad(v, m) {
   return `!(Number.isInteger(${v}/${m})||Math.abs(${v}/${m}-Math.round(${v}/${m}))<1e-9)`
 }
 
+// Own names only: a type called `__proto__` or `valueOf` read
+// Object.prototype's member and was handed out as the check, and the
+// Validator then threw on the first document (`_fast is not a function`).
+const typeCheckOf = (t) => (Object.prototype.hasOwnProperty.call(TYPE_CHECKS, t) ? TYPE_CHECKS[t] : undefined)
 const TYPE_CHECKS = {
   string: (d) => typeof d === 'string',
   number: (d) => Number.isFinite(d),
@@ -4198,7 +4202,11 @@ function genDynamicRefNode(schema, v, lines, ctx, knownType) {
 function genUniqueItemsNode(schema, v, lines, ctx, knownType, hoisted, isArr, types) {
   const si = ctx.varCounter++
   const itemType = schema.items && typeof schema.items === 'object' && schema.items.type
-  const isPrimItems = itemType === 'string' || itemType === 'number' || itemType === 'integer'
+  // `items` speaks for the elements after the tuple only: with `prefixItems`
+  // the first positions may hold objects, and comparing those by identity
+  // took two equal objects for different ones and accepted the array.
+  const noTuple = !Array.isArray(schema.prefixItems) || schema.prefixItems.length === 0
+  const isPrimItems = noTuple && (itemType === 'string' || itemType === 'number' || itemType === 'integer')
   const maxItems = schema.maxItems
   // Small primitive arrays (maxItems <= 16): nested loop is 6x faster than Set
   // No allocation, no hash computation — just direct === comparison

package/lib/plan-compiler.js

@@ -107,6 +107,7 @@ function install(deps) {
   function fresh() { return { props: null, n: 0, x: null, keys: null }; }
   // Object.keys once per record: every node that shares a record sees the
   // same data object.
+  const propEnum = Object.prototype.propertyIsEnumerable;
   function keysOf(rec, data) {
     if (rec.keys === null) rec.keys = Object.keys(data);
     return rec.keys;
@@ -609,9 +610,10 @@ function install(deps) {
       steps.push((data, errors, instancePath, schemaPath, stack, rec) => {
         if (dataBits(data) !== T_OBJECT) return true;
         let ok = true;
-        const keys = collect ? keysOf(rec, data) : Object.keys(data);
+        const keys = collect ? keysOf(rec, data) : Object.getOwnPropertyNames(data);
         if (pnFn !== null) {
           for (const k of keys) {
+            if (!collect && !propEnum.call(data, k)) continue;
             // propertyNames applies its subschema to the property NAME, not to
             // the value sitting at that key, so the failure is reported against
             // the object that carries the name rather than against `/<key>`.
@@ -643,7 +645,11 @@ function install(deps) {
             }
             evaluated = true;
           }
-          if (patterns !== null) {
+          // A name only properties lists is read whether enumerable or not,
+          // as the short walk above and the generated code read it by name;
+          // patterns and additionalProperties see the names for-in sees.
+          const seen = collect || prop !== undefined && patterns === null && apFn === null || propEnum.call(data, key);
+          if (patterns !== null && seen) {
             for (let pi = 0; pi < patterns.length; pi++) {
               const pp = patterns[pi];
               if (pp.re.test(key)) {
@@ -655,7 +661,7 @@ function install(deps) {
               }
             }
           }
-          if (!evaluated && apFn !== null) {
+          if (!evaluated && apFn !== null && seen) {
             if (apFalse) {
               ok = false;
               if (errors === NOERRORS) return false;
@@ -715,9 +721,9 @@ function install(deps) {
         vsteps.push((data, stack, rec) => {
         if (fusedLeaf !== null && !fusedLeaf(data)) return false;
         if (dataBits(data) !== T_OBJECT) return true;
-        const keys = collect ? keysOf(rec, data) : Object.keys(data);
+        const keys = collect ? keysOf(rec, data) : Object.getOwnPropertyNames(data);
         if (pnFn !== null) {
-          for (const k of keys) if (!pnFn.v(k, stack)) return false;
+          for (const k of keys) if ((collect || propEnum.call(data, k)) && !pnFn.v(k, stack)) return false;
         }
         let seenReq = 0;
         for (let k = 0; k < keys.length; k++) {
@@ -731,7 +737,8 @@ function install(deps) {
             if (prop.req) seenReq++;
             evaluated = true;
           }
-          if (patterns !== null) {
+          const seen = collect || prop !== undefined && patterns === null && apFn === null || propEnum.call(data, key);
+          if (patterns !== null && seen) {
             for (let pi = 0; pi < patterns.length; pi++) {
               const pp = patterns[pi];
               if (pp.re.test(key)) {
@@ -740,7 +747,7 @@ function install(deps) {
               }
             }
           }
-          if (!evaluated && apFn !== null) {
+          if (!evaluated && apFn !== null && seen) {
             if (!apFn.v(data[key], stack)) return false;
             evaluated = true;
           }
@@ -762,6 +769,13 @@ function install(deps) {
           const n = propKeys.length;
           const fns = propList.map((e) => e.fn);
           const reqs = propList.map((e) => e.req);
+          // Names met, as bits: the required ones must all be set, and a
+          // listed name not met may still be the object's own, hidden from
+          // for-in (defineProperty, enumerable: false), which the generated
+          // code and this engine's error path read by name: those are read
+          // after the walk, which on an ordinary document is the absent ones.
+          const reqMask = reqs.reduce((m, r, i) => r ? m | (1 << i) : m, 0);
+          const allMask = n === 32 ? -1 : (1 << n) - 1;
           // A property whose check is a coded leaf is checked in place.
           const codes = propList.map((e) => (e.fn.leaf && e.fn.v.lc !== undefined ? e.fn.v.lc : null));
           vsteps.push((data, stack, rec) => {
@@ -772,13 +786,21 @@ function install(deps) {
               let i = 0;
               while (i < n && propKeys[i] !== key) i++;
               if (i === n) { if (Object.hasOwn(data, key)) return false; continue; }
+              seen |= 1 << i;
               const value = data[key];
               if (value === undefined) { if (reqs[i]) return false; continue; }
               const lc = codes[i];
               if (lc !== null ? !leafOk(lc, value) : !fns[i].v(value, stack)) return false;
-              if (reqs[i]) seen++;
             }
-            return seen === reqN;
+            if ((seen & reqMask) !== reqMask) return false;
+            for (let miss = seen ^ allMask; miss !== 0; miss &= miss - 1) {
+              const i = 31 - Math.clz32(miss & -miss);
+              const value = data[propKeys[i]];
+              if (value === undefined || !Object.hasOwn(data, propKeys[i])) continue;
+              const lc = codes[i];
+              if (lc !== null ? !leafOk(lc, value) : !fns[i].v(value, stack)) return false;
+            }
+            return true;
           });
         }
       }

package/lib/regex-linear.js

@@ -36,6 +36,15 @@ const { parse } = require('./safe-regex')
 // holds them: every accepted pattern answers as the linear engine does and
 // stays fast on inputs built to make a backtracking engine retry.
 const NATIVE_ESCAPES = new Set(['d', 'D', 'w', 'W', 's', 'S', 'n', 'r', 't', 'f', 'v', '.', '\\', '/', '^', '$', '|', '?', '*', '+', '(', ')', '[', ']', '{', '}', '-', 'x', 'u'])
+// How many ways a backtracking engine can split one string over the bounded
+// choices of a pattern. Choices in a row multiply: `(a?){30}` is thirty
+// choices and two to the thirtieth ways, which the engine walks through on a
+// string that does not match. The count used to be a sum capped at 64, so
+// that pattern and `^([a-z]?){64}$` passed as linear and a string of 17
+// characters ran for more than half a minute. Now the product, capped where
+// the worst case stays under a millisecond for a hundred characters.
+const MAX_WAYS = 4096
+// The sum of bounded choices, which both rules below also hold to.
 const MAX_BOUNDED_CHOICES = 64
 
 const atom = (n) => n.t === 'char' || n.t === 'class' || n.t === 'any'
@@ -52,7 +61,9 @@ function anchored (ast) {
 function simpleRule (ast) {
   // Per subtree: how many unbounded quantifiers it holds (`u`) and how many
   // bounded choices a backtracking engine could try (`b`), or null where the
-  // shape is not provably linear.
+  // shape is not provably linear. The choices are held to a sum
+  // (MAX_BOUNDED_CHOICES: a long counted run is slow to compile and to
+  // unwind) and to a product (MAX_WAYS, waysOf below).
   const info = (n) => {
     switch (n.t) {
       case 'star': case 'plus':
@@ -78,7 +89,7 @@ function simpleRule (ast) {
     }
   }
   const r = info(ast)
-  if (r === null || r.u > 1 || r.b > MAX_BOUNDED_CHOICES) return false
+  if (r === null || r.u > 1 || r.b > MAX_BOUNDED_CHOICES || !(waysOf(ast) <= MAX_WAYS)) return false
   return r.u === 0 || anchored(ast)
 }
 
@@ -207,9 +218,31 @@ function deterministicRule (ast) {
   for (let p = 0; p < sets.length && ok; p++) disjoint(follow[p])
   if (!ok) return false
   if (bounded > MAX_BOUNDED_CHOICES) return false
+  // A counted repeat of a body that can end in more than one place is not a
+  // loop to the walk above (`(a?){30}`, `(a{1,8}){8}`), and it is where the
+  // ways multiply: the same product as the simple rule holds here too.
+  if (!(waysOf(ast) <= MAX_WAYS)) return false
   return unbounded === 0 || anchored(ast)
 }
 
+// The product the simple rule counts, over any shape: an unbounded
+// quantifier adds no bounded choice of its own.
+function waysOf (n) {
+  switch (n.t) {
+    case 'star': case 'plus': return waysOf(n.child)
+    case 'quest': return atom(n.child) ? 2 : 1 + waysOf(n.child)
+    case 'repeat': {
+      if (n.max === Infinity) return waysOf(n.child)
+      if (atom(n.child)) return n.max - n.min + 1
+      return (n.max - n.min + 1) * Math.pow(waysOf(n.child), n.max)
+    }
+    case 'group': return waysOf(n.child)
+    case 'concat': { let w = 1; for (const part of n.parts) w *= waysOf(part); return w }
+    case 'alt': { let w = 0; for (const part of n.opts) w += waysOf(part); return w }
+    default: return 1
+  }
+}
+
 // Two more shapes the rules above decline, both anchored with `^` and `$`
 // around one top-level sequence.
 //
@@ -393,6 +426,11 @@ function nativeIsLinear (src) {
   }
   let ast
   try { ast = parse(src) } catch { return false }
+  // The product of the bounded choices holds for every rule below, so it is
+  // asked here, once: the one-choice and delimited-loop rules did not ask it,
+  // and `^(a*b)*` followed by thirty `a?` reached the platform RegExp, where
+  // each `a?` more doubles the time on a string that does not match.
+  if (!(waysOf(ast) <= MAX_WAYS)) return false
   return simpleRule(ast) || deterministicRule(ast) || oneChoiceRule(ast) || delimitedLoopRule(ast)
 }
 

package/lib/scan-compiler.js

@@ -981,6 +981,12 @@ function emitObject(schema, ctx, out, depth) {
   const reqMasks = new Array(words).fill(0);
   if (required) for (const k of required) { const x = bit.get(k); reqMasks[x.w] |= x.b; }
 
+  // Many names are dispatched on a hash of the key, and two names with one
+  // hash cannot be: the code below then took the other branch, which reads
+  // variables only the few-names form declares, and the scanner threw a
+  // ReferenceError on every document that carried a declared key. Such a
+  // schema is left to the parser.
+  if (names.length >= HASH_DISPATCH_MIN && new Set(names.map(spanHash)).size !== names.length) decline('properties:hash-collision');
   out.push('c=s.charCodeAt(++i);');
   const useHash = names.length >= HASH_DISPATCH_MIN;
   if (useHash) {

package/lib/shape-classifier.js

@@ -40,9 +40,21 @@ function isPrimitiveEnumValue(v) {
   return v === null || t === 'string' || t === 'number' || t === 'boolean';
 }
 
+// A node of `enum` or `const` alone, no type: the values decide, as the full
+// engines decide it (enumMember, deepEqual), and every value is a primitive,
+// so a Set lookup or a === is the whole check. Form fields are written this
+// way often (`{ enum: ['TR', 'DE'] }`, `{ const: true }`), and one of them
+// sent the whole object to the slower engines.
+const TIER0_UNTYPED_ALLOWED = new Set(['enum', 'const', ...META_KEYS]);
+
 function isTier0Primitive(schema) {
   if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) return false;
-  if (!isPrimitiveType(schema.type)) return false;
+  if (!isPrimitiveType(schema.type)) {
+    if (schema.type !== undefined || (schema.enum === undefined && schema.const === undefined)) return false;
+    for (const k of Object.keys(schema)) {
+      if (!TIER0_UNTYPED_ALLOWED.has(k)) return false;
+    }
+  }
   for (const k of Object.keys(schema)) {
     if (!TIER0_PRIMITIVE_ALLOWED.has(k)) return false;
   }

package/lib/tier0.js

@@ -166,9 +166,10 @@ function checkPrimitive(c, v) {
     }
   } else if (m === T_BOOLEAN) {
     if (typeof v !== 'boolean') return false;
-  } else {
+  } else if (m !== 0) {
     return false;
   }
+  // m === 0: a node of enum or const alone; the checks below decide.
   if (c.hasEnum && !c.enumSet.has(v)) return false;
   if (c.hasConst && v !== c.constVal) return false;
   return true;
@@ -176,18 +177,32 @@ function checkPrimitive(c, v) {
 
 // Inlined object validator. Separating the primitive path removes a dead
 // branch from the hot object path.
-function tier0ValidateObject(plan, data) {
+// The object verdict as one closure over the plan's fields, read once: the
+// bound isValidObject() is then one call into a function whose loop reads
+// captured constants, where a plan passed each call cost two calls and a
+// field load per use (an empty object 17 ns against 7 for a validator built
+// the same way by hand; a number 9 against 4).
+function makeObjectVerdict(plan) {
+  const P_additionalAllowed = plan.additionalAllowed;
+  const P_constraints = plan.constraints;
+  const P_knownKeys = plan.knownKeys;
+  const P_requiredMask = plan.requiredMask;
+  return function tier0ObjectVerdict(data) {
   if (typeof data !== 'object' || data === null || Array.isArray(data)) return false;
-  const cs = plan.constraints;
+  const cs = P_constraints;
   const n = cs.length;
-  const reqMask = plan.requiredMask;
+  const reqMask = P_requiredMask;
+  // Whether the object is an ordinary one, read once: then a defined value
+  // under a name Object.prototype lacks is the object's own. Read for each
+  // present field, it was one test per field on a valid document.
+  const plain = (_PN ? data.__proto__ : Object.getPrototypeOf(data)) === Object.prototype;
   let seenMask = 0;
   for (let i = 0; i < n; i++) {
     const c = cs[i];
     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 || (_PN ? data.__proto__ : Object.getPrototypeOf(data)) !== Object.prototype) && !_hop.call(data, c.key)) v = undefined;
+    if (v !== undefined && (c.protoName || !plain) && !_hop.call(data, c.key)) v = undefined;
     if (v === undefined) {
       // A required key holding undefined is missing, as in every engine.
       if (reqMask & (1 << i)) return false;
@@ -225,21 +240,35 @@ function tier0ValidateObject(plan, data) {
       }
     } else if (m === T_BOOLEAN) {
       if (typeof v !== 'boolean') return false;
-    } else {
+    } else if (m !== 0) {
       return false;
     }
+    // m === 0: a node of enum or const alone; the checks below decide.
     if (c.hasEnum && !c.enumSet.has(v)) return false;
     if (c.hasConst && v !== c.constVal) return false;
   }
   if ((seenMask & reqMask) !== reqMask) return false;
-  if (!plan.additionalAllowed) {
-    const known = plan.knownKeys;
+  if (!P_additionalAllowed) {
+    const known = P_knownKeys;
     for (const k in data) {
       if (!Object.prototype.hasOwnProperty.call(data, k)) continue;
       if (!known.has(k)) return false;
     }
   }
   return true;
+  };
+}
+function tier0ValidateObject(plan, data) {
+  let f = plan._objectVerdict;
+  if (f === undefined) f = plan._objectVerdict = makeObjectVerdict(plan);
+  return f(data);
+}
+// The verdict for a plan as one closure, for a validator to bind directly.
+function tier0Verdict(plan) {
+  if (plan.isPrimitive) { const c = plan.constraints[0]; return (data) => checkPrimitive(c, data); }
+  let f = plan._objectVerdict;
+  if (f === undefined) f = plan._objectVerdict = makeObjectVerdict(plan);
+  return f;
 }
 
 function tier0Validate(plan, data) {
@@ -250,6 +279,7 @@ function tier0Validate(plan, data) {
 module.exports = {
   buildTier0Plan,
   tier0Validate,
+  tier0Verdict,
   tier0ValidateObject,
   checkPrimitive,
   TYPE_MASK,

package/lib/validator-core.js

@@ -1669,8 +1669,13 @@ class Validator {
   }
 
   addSchema(schema) {
-    if (this._initialized) {
-      throw new Error('Cannot add schema after compilation — call addSchema() before validate()')
+    // After a compile of either kind: the verdict-only one isValidObject()
+    // makes (_jsFn) binds a function over the registry as it was, and a
+    // schema added after it reached validate() but not isValidObject(),
+    // which kept answering against the old definition. A call the
+    // interpreted twin answered compiled nothing, and the twin is rebuilt.
+    if (this._initialized || this._jsFn) {
+      throw new Error('Cannot add schema after compilation: call addSchema() before validate(), isValidObject(), validateJSON() or isValidJSON()')
     }
     if (!schema || !schema.$id) {
       throw new Error('Schema must have $id')
@@ -2356,16 +2361,22 @@ function _ticks(self) {
 // _ticks says so.
 function _tier0Verdict(self) {
   if (require('./shape-classifier').classify(self._schemaObj).tier !== 0) return null;
-  const { buildTier0Plan, tier0Validate } = require('./tier0');
+  const { buildTier0Plan, tier0Verdict } = require('./tier0');
   const plan = buildTier0Plan(self._schemaObj, self._userFormats);
-  if (!_ticks(self)) return (d) => tier0Validate(plan, d);
+  const verdict = tier0Verdict(plan);
+  if (!_ticks(self)) return verdict;
   const tick = _tiering.counter(self);
-  return (d) => { tick(); return tier0Validate(plan, d); };
+  return (d) => { tick(); return verdict(d); };
 }
 
 Validator.prototype._coldTwin = function () {
   const cg = _loadCodegen();
-  return cg === null || cg.coldTwin === undefined ? null : cg.coldTwin(this, Validator);
+  // Where no code can be generated (a strict CSP), the interpreted engine is
+  // the compile itself: a twin would only delay it, and its size test read
+  // the schema's text for nothing (6.5% of a schema's first check there).
+  // The probe of the realm (codegenAvailable) is not run for a validator
+  // asked for the interpreted engine, which never generates code.
+  return cg === null || cg.coldTwin === undefined || this._interpretOnly || !codegenAvailable() ? null : cg.coldTwin(this, Validator);
 };
 
 _defineLazyMethod('validate', (self) => (data) => {
@@ -2402,7 +2413,14 @@ _defineLazyMethod('isValidObject', (self) => {
     _bindVerdict(self, _ticks(self) ? _t0 : (d) => {
       const r = _t0(d);
       if (++_n === 2) {
+        const before = self.isValidObject;
         try { self._ensureCodegen(); } catch {}
+        // Where the generated code did not take the method over (no code
+        // generation in this realm, or the generator declined), the plan's
+        // closure answers directly from now on: this wrapper cost every
+        // later call a count and a call, 13.5 against 4.7 ns on an empty
+        // object, on exactly the pages and workers that have no generator.
+        if (self.isValidObject === before) _bindVerdict(self, _t0);
       }
       return r;
     });

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.63.0",
+  "version": "1.63.2",
   "description": "JSON Schema validator that compiles to plain JavaScript, still runs where code generation is blocked, and can be compiled away at build time. Passes the full official test suite.",
   "type": "commonjs",
   "main": "index.js",
@@ -266,13 +266,13 @@
     "codegen.d.ts"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.63.0",
-    "@ata-validator/native-darwin-x64": "1.63.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.63.0",
-    "@ata-validator/native-linux-arm64-musl": "1.63.0",
-    "@ata-validator/native-linux-x64-gnu": "1.63.0",
-    "@ata-validator/native-linux-x64-musl": "1.63.0",
-    "@ata-validator/native-win32-x64": "1.63.0"
+    "@ata-validator/native-darwin-arm64": "1.63.2",
+    "@ata-validator/native-darwin-x64": "1.63.2",
+    "@ata-validator/native-linux-arm64-gnu": "1.63.2",
+    "@ata-validator/native-linux-arm64-musl": "1.63.2",
+    "@ata-validator/native-linux-x64-gnu": "1.63.2",
+    "@ata-validator/native-linux-x64-musl": "1.63.2",
+    "@ata-validator/native-win32-x64": "1.63.2"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"