ata-validator 1.53.0 → 1.55.0

package/lib/interpreter-core.js

@@ -460,6 +460,21 @@ class Plan {
         this.properties.set(key, { node: child(schema.properties[key]), seg: '/' + ek, schemaSeg: '/properties/' + ek });
       }
     }
+    // A required key holding undefined is missing. Where the key is also a
+    // declared property, the property walk, which reads the value anyway,
+    // finds that (requiredInProps); the required check reads the value only
+    // for the other keys (requiredUndef), so a valid object pays no second
+    // read of each required value.
+    this.requiredInProps = null;
+    this.requiredUndef = null;
+    if (this.required !== null) {
+      const undef = this.required.map((k) => this.properties === null || !this.properties.has(k));
+      if (undef.includes(true)) this.requiredUndef = undef;
+      if (this.properties !== null) {
+        const inProps = this.required.filter((k) => this.properties.has(k));
+        if (inProps.length > 0) this.requiredInProps = new Set(inProps);
+      }
+    }
     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]) }));
@@ -601,7 +616,8 @@ function evalLeafV(P, data) {
     if (P.required !== null) {
       const req = P.required;
       for (let i = 0; i < req.length; i++) {
-        if (!Object.hasOwn(data, req[i])) return false;
+        // A key holding undefined is missing, as in the default validator.
+        if (!Object.hasOwn(data, req[i]) || (P.requiredUndef !== null && P.requiredUndef[i] && data[req[i]] === undefined)) return false;
       }
     }
     if (P.minProperties !== undefined && Object.keys(data).length < P.minProperties) return false;
@@ -659,71 +675,6 @@ function dataCtx(instancePath, schemaPath, keyword) {
   return { instancePath, parentData: parent, parentDataProperty: key, rootData: root, schemaPath: schemaPath + '/' + keyword };
 }
 
-function isDiscriminated(schema) {
-  const d = schema.discriminator;
-  return d !== null && typeof d === 'object' && typeof d.propertyName === 'string';
-}
-
-// The reference's coercion: the first type in the list the value converts to,
-// after unwrapping a one-element array in 'array' mode, which then converts
-// the element.
-const NO_COERCION = Symbol('no coercion');
-function fitsType(d, t) {
-  switch (t) {
-    case 'string': return typeof d === 'string';
-    case 'number': return typeof d === 'number' && isFinite(d);
-    case 'integer': return typeof d === 'number' && Number.isInteger(d);
-    case 'boolean': return typeof d === 'boolean';
-    case 'null': return d === null;
-    case 'array': return Array.isArray(d);
-    case 'object': return d !== null && typeof d === 'object' && !Array.isArray(d);
-    default: return false;
-  }
-}
-// Whether an unwrapped element is kept as it is. The reference tests a list
-// of types here with every type at once, so a list of two or more keeps
-// nothing (`number` stands in for `integer` beside it), and the element goes
-// on to be converted, as one of a single type does when it does not fit.
-function unwrappedFits(d, types) {
-  let list = types;
-  if (list.length > 1 && list.includes('number')) list = list.filter((t) => t !== 'integer');
-  if (list.length > 1 && list.includes('array') && list.includes('object')) return false;
-  for (const t of list) if (!fitsType(d, t)) return false;
-  return true;
-}
-function coerceValue(data, types, arrayMode) {
-  if (arrayMode && Array.isArray(data) && data.length === 1) {
-    data = data[0];
-    if (unwrappedFits(data, types)) return data;
-  }
-  const kind = data === null ? 'null' : typeof data;
-  for (const t of types) {
-    switch (t) {
-      case 'number':
-      case 'integer':
-        if (kind === 'boolean' || kind === 'null') return +data;
-        // eslint-disable-next-line eqeqeq
-        if (kind === 'string' && data !== '' && data == +data && (t === 'number' || !(data % 1))) return +data;
-        break;
-      case 'string':
-        if (kind === 'number' || kind === 'boolean') return '' + data;
-        if (kind === 'null') return '';
-        break;
-      case 'boolean':
-        if (data === 'false' || data === 0 || data === null) return false;
-        if (data === 'true' || data === 1) return true;
-        break;
-      case 'null':
-        if (data === '' || data === 0 || data === false) return null;
-        break;
-      case 'array':
-        if (arrayMode && (kind === 'string' || kind === 'number' || kind === 'boolean' || kind === 'null')) return [data];
-        break;
-    }
-  }
-  return NO_COERCION;
-}
-
 // After a context-reading keyword, the value is read again from where it sits:
 // the keyword may have replaced it (a date deserialized, a value serialized),
 // and the keywords after it check what it left, as the default validator's
@@ -855,7 +806,7 @@ function evalLeaf(P, data, errors, instancePath, schemaPath) {
       const req = P.required;
       for (let i = 0; i < req.length; i++) {
         const key = req[i];
-        if (!Object.hasOwn(data, key)) { errors === NOERRORS || errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`)); valid = false; }
+        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; }
@@ -909,6 +860,9 @@ class Interpreter {
     // `discriminator` option: the tag picks the one oneOf branch to apply.
     this.discriminator = opts.discriminator === true;
     this._discr = null;
+    // Both come from compat, which installs the code for them (see
+    // lib/interpreter-compat.js), so a bundle without compat carries none of it.
+    this.ext = this.coerce !== false || this.discriminator ? compatExt() : null;
     // The compiled closures know none of these.
     if (this.dataContext || this.discriminator || this.numberFormats !== null) this._fast = null;
     this._ctxRoot = undefined;
@@ -922,7 +876,14 @@ class Interpreter {
     if (this._fast === undefined) {
       const compile = planCompiler();
       if (compile === null) this._fast = null;
-      else try { this._fast = compile(this); } catch { this._fast = null; }
+      else {
+        try { this._fast = compile(this); } catch (e) {
+          // The plain walk answers instead, which tests cannot tell apart;
+          // tests/test_plan_compiles.js holds the compiler to the suite.
+          if (typeof process === 'object' && process !== null && process.env && process.env.ATA_DEBUG) console.error('ata: plan compiler failed, plain walk used:', e && e.message);
+          this._fast = null;
+        }
+      }
     }
     return this._fast;
   }
@@ -1028,75 +989,6 @@ class Interpreter {
     }
   }
 
-  // The discriminator in place of oneOf: the branch the tag names is applied,
-  // and a tag that is not a string, or names no branch, is the error.
-  discriminate(P, data, base, dynScope, errors, instancePath, schemaPath, stack, local) {
-    const d = this.discrMap(P, base);
-    const tag = data[d.tagName];
-    if (typeof tag !== 'string') {
-      if (errors !== NOERRORS) errors.push(err('discriminator', 'discriminator', instancePath, schemaPath + '/discriminator', { error: 'tag', tag: d.tagName, tagValue: tag }, `tag "${d.tagName}" must be string`));
-      return false;
-    }
-    const i = d.map.get(tag);
-    if (i === undefined) {
-      if (errors !== NOERRORS) errors.push(err('discriminator', 'discriminator', instancePath, schemaPath + '/discriminator', { error: 'mapping', tag: d.tagName, tagValue: tag }, `value of tag "${d.tagName}" must be in oneOf`));
-      return false;
-    }
-    const sub = local !== DISCARD ? { props: null, items: null } : DISCARD;
-    const ok = this.eval(P.oneOf[i], data, base, dynScope, errors, instancePath, schemaPath + '/oneOf/' + i, stack, sub);
-    if (ok && local !== DISCARD) mergeAnnotations(local, sub);
-    return ok;
-  }
-
-  // Tag value to branch index, read from each branch's `properties`, through
-  // a `$ref`, with the reference's rules: a `const` or `enum` of unique
-  // strings, and the tag required by the node or by every branch.
-  discrMap(P, base) {
-    if (this._discr === null) this._discr = new Map();
-    let d = this._discr.get(P);
-    if (d !== undefined) return d;
-    const tagName = P.schema.discriminator.propertyName;
-    if (P.schema.discriminator.mapping !== undefined) throw new Error('discriminator: mapping is not supported');
-    const hasRequired = (s) => s !== null && typeof s === 'object' && Array.isArray(s.required) && s.required.includes(tagName);
-    let topRequired = hasRequired(P.schema);
-    const map = new Map();
-    for (let i = 0; i < P.oneOf.length; i++) {
-      let node = P.oneOf[i];
-      if (node !== null && typeof node === 'object' && node.ref !== null && node.ref !== undefined && (node.schema.properties === undefined)) {
-        const r = this.resolveRefCached(node, base);
-        if (r.child === undefined) throw new Error(`discriminator: cannot resolve $ref ${node.ref}`);
-        node = r.child;
-      }
-      const sch = node !== null && typeof node === 'object' ? node.schema : undefined;
-      const propSch = sch && sch.properties ? sch.properties[tagName] : undefined;
-      if (propSch === null || typeof propSch !== 'object') throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`);
-      topRequired = topRequired || hasRequired(sch);
-      const values = propSch.const !== undefined ? [propSch.const] : Array.isArray(propSch.enum) ? propSch.enum : null;
-      if (values === null) throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`);
-      for (const v of values) {
-        if (typeof v !== 'string' || map.has(v)) throw new Error(`discriminator: "${tagName}" values must be unique strings`);
-        map.set(v, i);
-      }
-    }
-    if (!topRequired) throw new Error(`discriminator: "${tagName}" must be required`);
-    d = { tagName, map };
-    this._discr.set(P, d);
-    return d;
-  }
-
-  // Coerces the value at `instancePath` to the node's type and writes it where
-  // it sits; at the root, where it sits nowhere, the walk carries it on.
-  coerceAt(P, data, instancePath) {
-    const to = coerceValue(data, P.typeNames, this.coerce === 'array');
-    if (to === NO_COERCION) return data;
-    if (instancePath === '') this._ctxRoot = to;
-    else {
-      const ctx = dataCtx(instancePath, '', '');
-      if (ctx.parentData !== null && typeof ctx.parentData === 'object') ctx.parentData[ctx.parentDataProperty] = to;
-    }
-    return to;
-  }
-
   // The value at `instancePath` as it is now, after a subschema may have
   // coerced it.
   here(instancePath, data) {
@@ -1183,7 +1075,7 @@ class Interpreter {
     const local = collect ? { props: null, items: null } : DISCARD;
 
     // Coercion first, before anything reads the value, as the reference does it.
-    if (this.coerce !== false && P.hasType && (dataBits(data) & P.typeMask) === 0) data = this.coerceAt(P, data, instancePath);
+    if (this.coerce !== false && P.hasType && (dataBits(data) & P.typeMask) === 0) data = this.ext.coerceAt(this, P, data, instancePath);
 
     // $ref / $dynamicRef: in-place applicators, annotations flow through
     if (P.ref !== null) {
@@ -1331,7 +1223,7 @@ class Interpreter {
         const req = P.required;
         for (let i = 0; i < req.length; i++) {
           const key = req[i];
-          if (!Object.hasOwn(data, key)) { errors === NOERRORS || errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`)); valid = false; }
+          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; }
@@ -1359,8 +1251,12 @@ class Interpreter {
         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
-          // serialized the key is not there.
-          if (data[key] !== undefined && !this.eval(prop.node, data[key], base, dynScope, errors, E ? instancePath + prop.seg : '', E ? schemaPath + prop.schemaSeg : '', stack, DISCARD)) valid = false;
+          // serialized the key is not there. Required, it is missing (see
+          // requiredInProps).
+          const value = data[key];
+          if (value !== undefined) {
+            if (!this.eval(prop.node, value, base, dynScope, errors, E ? instancePath + prop.seg : '', E ? schemaPath + prop.schemaSeg : '', stack, DISCARD)) valid = false;
+          } 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) {
@@ -1467,8 +1363,8 @@ class Interpreter {
           valid = false;
         }
       }
-      if (P.oneOf !== null && this.discriminator && isDiscriminated(schema)) {
-        if (bits === T_OBJECT && !this.discriminate(P, data, base, dynScope, errors, instancePath, schemaPath, stack, collect ? local : DISCARD)) valid = false;
+      if (P.oneOf !== null && this.discriminator && this.ext.isDiscriminated(schema)) {
+        if (bits === T_OBJECT && !this.ext.discriminate(this, P, data, base, dynScope, errors, instancePath, schemaPath, stack, collect ? local : DISCARD)) valid = false;
       } else if (P.oneOf !== null) {
         let count = 0;
         let winner = null;
@@ -1613,18 +1509,33 @@ function planCompiler() {
     compileInterpreter = loadPlanCompiler()({
       Plan, NOERRORS, err, evalLeaf, evalLeafV, runCustomV, dataBits, escapePointer,
       deepEqual, enumMember, allDistinct, multipleOfOk, cpAtLeast, cpAtMost,
-      T_STRING, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri,
+      T_STRING, T_NUMBER, T_INTEGER, T_BOOLEAN, T_NULL, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri,
     }).compileInterpreter;
   }
   return compileInterpreter;
 }
 
+let installCompat = null;
+let compatInstalled = null;
+function setCompat(install) {
+  installCompat = install;
+  compatInstalled = null;
+}
+function compatExt() {
+  if (compatInstalled === null) {
+    if (installCompat === null) throw new Error('coercion where each type is checked and the discriminator are installed by ata-validator/compat');
+    compatInstalled = installCompat({ NOERRORS, DISCARD, err, mergeAnnotations, dataCtx });
+  }
+  return compatInstalled;
+}
+
 function createInterpreter(schema, options) {
   return new Interpreter(schema, options);
 }
 
 module.exports = { createInterpreter };
 Object.defineProperty(module.exports, '_setPlanCompiler', { value: setPlanCompiler, enumerable: false });
+Object.defineProperty(module.exports, '_setCompat', { value: setCompat, enumerable: false });
 // The resolver, for the code generator: it resolves references at compile
 // time the way this engine does at run time (normalizeRefs in js-compiler).
 Object.defineProperty(module.exports, '_refInternals', {

package/lib/js-compiler-errors.js

@@ -9,7 +9,7 @@ const { compileFunction } = require('./compile-fn')
 // the first call that compiles errors. Everything here was written as part
 // of js-compiler.js and reads its helpers from that module's _internal.
 const core = require('./js-compiler')
-const { ownHead, hasConstraints, assertEmitted, prepareForCodegen, sharedCodegenGate, codegenSafe, isSimplePN, hasUnresolvableRef, needsBaseTracking, _cpLen, sharedRt, DECLINE, bindRt, compileSafe, emitGuardState, withPlain, REF_NEUTRAL_SIBLINGS, resolveCrossSchemaRef, enumCondition, enumOperand, emitDeq, emitConstant, ownGuard, ownKeyExpr, multipleOfBad, compilePatternInline, useSafeEngine, reFlags, FORMAT_CODEGEN, PROTO_NAMES, setOwn, nestedGenCode, compileToJSCodegen, SKIP_VALUE_KEYS, skipString, CYCLE_DEPTH, cyclicDefNames, sharedDefNames, reFlagArg, hoistOnce, PTR_ESC_HELPER, unevalContributions, emitUq, uqSources, safeReClosure, fastPrefixCheck, replaceTopLevel, refTargetFor, genCode, addLocalAnnotations, addTopApplicatorAnnotations, protoIs, ANNOT_APPLICATORS, SIZE_SKIPS, emitRootGuard, emitGuardedRun } = core._internal
+const { ownHead, hasConstraints, assertEmitted, prepareForCodegen, sharedCodegenGate, codegenSafe, isSimplePN, hasUnresolvableRef, needsBaseTracking, _cpLen, sharedRt, DECLINE, bindRt, compileSafe, emitGuardState, withPlain, REF_NEUTRAL_SIBLINGS, resolveCrossSchemaRef, enumCondition, enumOperand, emitDeq, emitConstant, ownGuard, ownKeyExpr, multipleOfBad, compilePatternInline, useSafeEngine, reFlags, FORMAT_CODEGEN, PROTO_NAMES, setOwn, nestedGenCode, compileToJSCodegen, SKIP_VALUE_KEYS, skipString, CYCLE_DEPTH, cyclicDefNames, sharedDefNames, reFlagArg, hoistOnce, PTR_ESC_HELPER, unevalContributions, emitUq, uqSources, safeReClosure, fastPrefixCheck, replaceTopLevel, refTargetFor, genCode, addLocalAnnotations, addTopApplicatorAnnotations, protoIs, ANNOT_APPLICATORS, SIZE_SKIPS, emitRootGuard, emitGuardedRun, keyLoopEligible, SAME_KEYS_HELPER, seqTag } = core._internal
 
 
 function emitPtrEsc(ctx) {
@@ -590,9 +590,19 @@ function subtreeGuard (sub, ctx, gv) {
   // 25-definition API schema came to 55 KB of source in a 133 KB function,
   // and a function that size reaches the optimizing compiler late.
   ctx.shareDefs = true
+  // A record of many optional properties takes the verdict's key-loop form
+  // (keyLoopEligible): its optional properties are checked from the record's
+  // own keys. Written one read per property, the guard of a 150-property
+  // record was 16.9 KB, over GUARD_MAX, so there was no guard at all and
+  // every record of the list was collected in full; on records of mixed
+  // shapes those reads are megamorphic, and 2000 of them cost 18 ms where
+  // the verdict took 0.3. The key-loop form is 10 KB and reads only the keys
+  // the record has.
+  const outerKeyLoop = ctx.keyLoopNode
+  if (keyLoopEligible(sub)) ctx.keyLoopNode = sub
   try {
     const bl = []
-    try { nestedGenCode(sub, gv, bl, ctx) } finally { ctx.defFns = outerDefFns; ctx.shareDefs = outerShare }
+    try { nestedGenCode(sub, gv, bl, ctx) } finally { ctx.defFns = outerDefFns; ctx.shareDefs = outerShare; ctx.keyLoopNode = outerKeyLoop }
     if (bl.length === 0) { restoreCtx(ctx, saved); return null }
     const body = bl.join(';')
     // The verdict generator's recursion names (`_validate`, the cycle guard
@@ -612,17 +622,20 @@ function subtreeGuard (sub, ctx, gv) {
   }
 }
 // The collecting code for `sub` at `v`, behind its guard when there is one.
-function genGuardedC (sub, v, pathExpr, lines, ctx, schemaPrefix) {
+// `when`, a boolean variable, makes the guard conditional: when it is false
+// the value is collected without a verdict first (see the items case).
+function genGuardedC (sub, v, pathExpr, lines, ctx, schemaPrefix, when) {
   const gi = ctx.varCounter++
   const gv = `_gv${gi}`
   const g = subtreeGuard(sub, ctx, gv)
   if (g === null) { genCodeC(sub, v, pathExpr, lines, ctx, schemaPrefix); return }
-  if (g.name !== undefined) lines.push(`if(!${g.name}(${v})){`)
+  const cond = when ? `!${when}||` : ''
+  if (g.name !== undefined) lines.push(`if(${cond}!${g.name}(${v})){`)
   else {
     // The verdict's exits become jumps out of the block: a failure leaves
     // the flag set, success clears it. replaceTopLevel keeps nested
     // closures' returns as they are (see the hybrid rewrite).
-    lines.push(`{const ${gv}=${v};let _g${gi}=1;g${gi}:{${replaceTopLevel(g.body, `{_g${gi}=0;break g${gi}}`, `break g${gi}`)};_g${gi}=0}if(_g${gi}){`)
+    lines.push(`{const ${gv}=${v};let _g${gi}=1;${when ? `if(${when})` : ''}g${gi}:{${replaceTopLevel(g.body, `{_g${gi}=0;break g${gi}}`, `break g${gi}`)};_g${gi}=0}if(_g${gi}){`)
   }
   ctx.guardDepth = (ctx.guardDepth || 0) + 1
   try { genCodeC(sub, v, pathExpr, lines, ctx, schemaPrefix) } finally { ctx.guardDepth-- }
@@ -1164,7 +1177,7 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const reqSp = `${schemaPrefix}/required`
     const reqLit = buildErrorLiteral({ keyword: 'required', schemaPath: reqSp, sourceMap: ctx.sourceMap })
     for (const key of schema.required) {
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){_e.push({code:'${reqLit.codeStr}',keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${reqSp}'${ordinalField(ctx, `${reqSp}`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'",docUrl:'${reqLit.docUrl}'${reqLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&(${v}[${JSON.stringify(key)}]===undefined||!${ownGuard(ctx, v, key)})){_e.push({code:'${reqLit.codeStr}',keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${reqSp}'${ordinalField(ctx, `${reqSp}`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'",docUrl:'${reqLit.docUrl}'${reqLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
     }
   }
 
@@ -1354,7 +1367,8 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       const childPath = childPathExpr(pathExpr, ptrSeg(key))
       const sp = schemaPrefix+'/properties/'+ptrSeg(key)
       const from = lines.length
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
+      // A value that is undefined is not checked (see the verdict generator).
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${v}[${JSON.stringify(key)}]!==undefined&&${ownKeyExpr(ctx, v, key)}){`)
       // A large subschema as a function of its own (emitPropFnE); false means inline.
       if (!propFnCandidateE(prop, ctx, sp) || !emitPropFnE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, sp)) {
         genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, sp)
@@ -1769,7 +1783,10 @@ function errPushC(ctx, keyword, sp, pathExpr, paramsCode, msgCode, valueExpr, le
   // the definition and the reference's own comes in as `_sp`.
   const rel = sp.startsWith(SP_PLACEHOLDER)
   ctx.closureVals.push(errorSite(keyword, unescapeSp(rel ? sp.slice(SP_PLACEHOLDER.length) : sp), paramsVal, fmt))
-  return `(_e=_ap(_A,_e,_mk(${siteVar},${pathExpr || '""'},${paramsShared || paramsCode},${msgCode},${valueExpr},d${rel ? ',_sp' : ''}),-1))`
+  // The site's ordinal key, as the plain form passes it: a list that comes out
+  // in order then needs no sorting, and one that does not is put in order from
+  // the keys collected beside it (sr) instead of looking up each error's path.
+  return `(_e=_ap(_A,_e,_mk(${siteVar},${pathExpr || '""'},${paramsShared || paramsCode},${msgCode},${valueExpr},d${rel ? ',_sp' : ''}),${apOrd(ctx, sp)}))`
 }
 
 function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts) {
@@ -1935,7 +1952,10 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
       // The checked sort (_srX) compares with the reader, which a module
       // does not carry: there `_SRT` keeps the list as it is.
       `\n  return _e?new _ER(_A.mo?_e:${env('ATA_CHECK_SORT') && !(opts && opts.emit) ? '_srX(_A,_e,_SRT)' : '_sr(_A,_e,_SRT)'}):${opts && opts.moduleShape ? 'R' : '{valid:true,data:d,errors:_EE}'}}catch(_x){return _FB(d)}`
-    : hoistDecl + allDecl + `let _e;${AP_RESET}\n  ` + checks + `\n  return _e?{valid:false,errors:_e}:R`
+    // The rich form also says whether its list came out in the reader's
+    // order (`mo`, kept by _ap from each site's ordinal key), so the reader
+    // (richBuilder) sorts only a list that did not.
+    : hoistDecl + allDecl + `let _e;${AP_RESET}\n  ` + checks + `\n  return _e?{valid:false,errors:_e${ctx.rich ? ',mo:_A.mo' : ''}}:R`
   // The verdict generator's hoisted functions (subtreeGuard writes guards
   // through it) come first: a oneOf branch it could not hoist was a closure
   // built at every call of the guard, six per element of a json-patch list.
@@ -1952,7 +1972,8 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
       console.log('=== COMBINED PARTS ===', JSON.stringify(Object.entries(acc).sort((a, b) => b[1] - a[1])))
     }
     const programSrc = assignOrdKeys(ctx, `${helpers}return function _vC(d){${inner}}`)
-    const factory = compileFunction('R' + (closureParams ? ',' + closureParams : ''), programSrc)
+    // The run-time program is tagged (seqTag); the emitted source is not.
+    const factory = compileFunction('R' + (closureParams ? ',' + closureParams : ''), (opts && opts.emit ? '' : seqTag()) + programSrc)
     const made = factory(VALID_RESULT, ...closureArgs)
     // For a standalone module (lib/aot-impl.js): the program's source and the
     // closure values it takes, after the function was built and tried on
@@ -2405,7 +2426,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       }
     }
     for (const key of schema.required) {
-      const check = hoisted[key] ? `${hoisted[key]}===undefined` : `!${ownKeyExpr(ctx, v, key)}`
+      const check = hoisted[key] ? `${hoisted[key]}===undefined` : `(${v}[${JSON.stringify(key)}]===undefined||!${ownGuard(ctx, v, key)})`
       if (isStaticPath && !ctx.rich && !ctx.noOrdinal) {
         const ei = ctx.varCounter++
         const errVar = `_E${ei}`
@@ -2428,7 +2449,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         ctx.closureVals.push(sharedErr({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/required`), params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}, ctx.rootSchema))
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){(_e=_ap(_A,_e,${errVar},${apOrd(ctx, `${schemaPrefix}/required`)}))}`)
       } else {
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){${errPushC(ctx, 'required', `${schemaPrefix}/required`, pathExpr, `{missingProperty:'${esc(key)}'}`, `"must have required property '${esc(key)}'"`, v, `{keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"}`)}}`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&(${v}[${JSON.stringify(key)}]===undefined||!${ownGuard(ctx, v, key)})){${errPushC(ctx, 'required', `${schemaPrefix}/required`, pathExpr, `{missingProperty:'${esc(key)}'}`, `"must have required property '${esc(key)}'"`, v, `{keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"}`)}}`)
       }
     }
   }
@@ -2612,7 +2633,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         sub(`_o${oi}`)
         lines.push(`}}`)
       } else {
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${v}[${JSON.stringify(key)}]!==undefined&&${ownKeyExpr(ctx, v, key)}){`)
         sub(`${v}[${JSON.stringify(key)}]`)
         lines.push(`}`)
       }
@@ -2643,9 +2664,24 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const idx = `_j${ctx.varCounter}`, elem = `_ei${ctx.varCounter}`
     ctx.varCounter++
     const childPath = childPathDynExpr(pathExpr, idx)
-    lines.push(`if(Array.isArray(${v})){for(let ${idx}=${startIdx};${idx}<${v}.length;${idx}++){const ${elem}=${v}[${idx}]`)
-    genGuardedC(schema.items, elem, childPath, lines, ctx, schemaPrefix+'/items')
-    lines.push(`}}`)
+    if (ctx.inCombined && keyLoopEligible(schema.items)) {
+      // Records of many optional properties (see subtreeGuard): the guard,
+      // a key loop per record, is run only for a list of mixed shapes,
+      // decided as the verdict decides (the first, middle and last record's
+      // keys). On records of one shape the collecting code's reads are
+      // monomorphic and cheaper than any guard: 2000 uniform records read
+      // for errors in 16 us, with a guard on each 69.
+      hoistOnce(ctx, 'sameKeysHelper', SAME_KEYS_HELPER)
+      const n = `_n${ctx.varCounter++}`
+      const mx = `_mx${ctx.varCounter++}`
+      lines.push(`if(Array.isArray(${v})){const ${n}=${v}.length;const ${mx}=${n}-${startIdx}>2&&(!_sameKeys(${v}[${startIdx}],${v}[(${n}+${startIdx})>>1])||!_sameKeys(${v}[${startIdx}],${v}[${n}-1]));for(let ${idx}=${startIdx};${idx}<${n};${idx}++){const ${elem}=${v}[${idx}]`)
+      genGuardedC(schema.items, elem, childPath, lines, ctx, schemaPrefix+'/items', mx)
+      lines.push(`}}`)
+    } else {
+      lines.push(`if(Array.isArray(${v})){for(let ${idx}=${startIdx};${idx}<${v}.length;${idx}++){const ${elem}=${v}[${idx}]`)
+      genGuardedC(schema.items, elem, childPath, lines, ctx, schemaPrefix+'/items')
+      lines.push(`}}`)
+    }
   }
 
   // prefixItems