ata-validator 1.63.0 → 1.63.1

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

@@ -44,7 +44,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 +103,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 +296,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 +334,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 +354,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 +373,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 +421,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 +441,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 +515,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 +559,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/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/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.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.63.0",
+  "version": "1.63.1",
   "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.1",
+    "@ata-validator/native-darwin-x64": "1.63.1",
+    "@ata-validator/native-linux-arm64-gnu": "1.63.1",
+    "@ata-validator/native-linux-arm64-musl": "1.63.1",
+    "@ata-validator/native-linux-x64-gnu": "1.63.1",
+    "@ata-validator/native-linux-x64-musl": "1.63.1",
+    "@ata-validator/native-win32-x64": "1.63.1"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"