ata-validator 1.53.0 → 1.55.0

package/lib/metaschemas.js

@@ -2,11 +2,12 @@
 
 // The official meta-schemas, vendored so a `$ref` to one of them resolves
 // without a network. Draft 2020-12 is eight documents joined by $dynamicRef;
-// draft-07 and draft-06 are one each; 2019-09 is seven. Sources:
+// draft-07, draft-06 and draft-04 are one each; 2019-09 is seven. Sources:
 // https://json-schema.org/draft/2020-12/schema and
-// http://json-schema.org/draft-07/schema, fetched 2026-08-23, and
+// http://json-schema.org/draft-07/schema, fetched 2026-08-23,
 // http://json-schema.org/draft-06/schema and
-// https://json-schema.org/draft/2019-09/schema, fetched 2026-10-10, unmodified.
+// https://json-schema.org/draft/2019-09/schema, fetched 2026-10-10, and
+// http://json-schema.org/draft-04/schema, fetched 2026-10-14, unmodified.
 // The 2019-09 documents are read through the same 2019-09 rewrite as a
 // caller's schema (lib/draft7.js) once, at load, since they use
 // `$recursiveRef`, which the engines read as `$dynamicRef`.
@@ -22,6 +23,7 @@ const METASCHEMAS = new Map([
   ["https://json-schema.org/draft/2020-12/meta/content", {"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/content","$dynamicAnchor":"meta","title":"Content vocabulary meta-schema","type":["object","boolean"],"properties":{"contentEncoding":{"type":"string"},"contentMediaType":{"type":"string"},"contentSchema":{"$dynamicRef":"#meta"}}}],
   ["https://json-schema.org/draft/2020-12/meta/unevaluated", {"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/unevaluated","$dynamicAnchor":"meta","title":"Unevaluated applicator vocabulary meta-schema","type":["object","boolean"],"properties":{"unevaluatedItems":{"$dynamicRef":"#meta"},"unevaluatedProperties":{"$dynamicRef":"#meta"}}}],
   ["http://json-schema.org/draft-07/schema#", {"$schema":"http://json-schema.org/draft-07/schema#","$id":"http://json-schema.org/draft-07/schema#","title":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"allOf":[{"$ref":"#/definitions/nonNegativeInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}},"type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference"},"$schema":{"type":"string","format":"uri"},"$ref":{"type":"string","format":"uri-reference"},"$comment":{"type":"string"},"title":{"type":"string"},"description":{"type":"string"},"default":true,"readOnly":{"type":"boolean","default":false},"writeOnly":{"type":"boolean","default":false},"examples":{"type":"array","items":true},"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/definitions/nonNegativeInteger"},"minLength":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"$ref":"#"},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":true},"maxItems":{"$ref":"#/definitions/nonNegativeInteger"},"minItems":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"contains":{"$ref":"#"},"maxProperties":{"$ref":"#/definitions/nonNegativeInteger"},"minProperties":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"$ref":"#"},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"propertyNames":{"format":"regex"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"propertyNames":{"$ref":"#"},"const":true,"enum":{"type":"array","items":true,"minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"contentMediaType":{"type":"string"},"contentEncoding":{"type":"string"},"if":{"$ref":"#"},"then":{"$ref":"#"},"else":{"$ref":"#"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"default":true}],
+  ["http://json-schema.org/draft-04/schema#", {"id":"http://json-schema.org/draft-04/schema#","$schema":"http://json-schema.org/draft-04/schema#","description":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"positiveInteger":{"type":"integer","minimum":0},"positiveIntegerDefault0":{"allOf":[{"$ref":"#/definitions/positiveInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"minItems":1,"uniqueItems":true}},"type":"object","properties":{"id":{"type":"string"},"$schema":{"type":"string"},"title":{"type":"string"},"description":{"type":"string"},"default":{},"multipleOf":{"type":"number","minimum":0,"exclusiveMinimum":true},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"boolean","default":false},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"boolean","default":false},"maxLength":{"$ref":"#/definitions/positiveInteger"},"minLength":{"$ref":"#/definitions/positiveIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"anyOf":[{"type":"boolean"},{"$ref":"#"}],"default":{}},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":{}},"maxItems":{"$ref":"#/definitions/positiveInteger"},"minItems":{"$ref":"#/definitions/positiveIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"maxProperties":{"$ref":"#/definitions/positiveInteger"},"minProperties":{"$ref":"#/definitions/positiveIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"anyOf":[{"type":"boolean"},{"$ref":"#"}],"default":{}},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"enum":{"type":"array","minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"dependencies":{"exclusiveMaximum":["maximum"],"exclusiveMinimum":["minimum"]},"default":{}}],
   ["http://json-schema.org/draft-06/schema#", {"$schema":"http://json-schema.org/draft-06/schema#","$id":"http://json-schema.org/draft-06/schema#","title":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"allOf":[{"$ref":"#/definitions/nonNegativeInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}},"type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference"},"$schema":{"type":"string","format":"uri"},"$ref":{"type":"string","format":"uri-reference"},"title":{"type":"string"},"description":{"type":"string"},"default":{},"examples":{"type":"array","items":{}},"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/definitions/nonNegativeInteger"},"minLength":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"$ref":"#"},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":{}},"maxItems":{"$ref":"#/definitions/nonNegativeInteger"},"minItems":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"contains":{"$ref":"#"},"maxProperties":{"$ref":"#/definitions/nonNegativeInteger"},"minProperties":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"$ref":"#"},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"propertyNames":{"format":"regex"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"propertyNames":{"$ref":"#"},"const":{},"enum":{"type":"array","minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"default":{}}],
   ["https://json-schema.org/draft/2019-09/schema", {"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/schema","$vocabulary":{"https://json-schema.org/draft/2019-09/vocab/core":true,"https://json-schema.org/draft/2019-09/vocab/applicator":true,"https://json-schema.org/draft/2019-09/vocab/validation":true,"https://json-schema.org/draft/2019-09/vocab/meta-data":true,"https://json-schema.org/draft/2019-09/vocab/format":false,"https://json-schema.org/draft/2019-09/vocab/content":true},"$recursiveAnchor":true,"title":"Core and Validation specifications meta-schema","allOf":[{"$ref":"meta/core"},{"$ref":"meta/applicator"},{"$ref":"meta/validation"},{"$ref":"meta/meta-data"},{"$ref":"meta/format"},{"$ref":"meta/content"}],"type":["object","boolean"],"properties":{"definitions":{"$comment":"While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.","type":"object","additionalProperties":{"$recursiveRef":"#"},"default":{}},"dependencies":{"$comment":"\"dependencies\" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to \"dependentSchemas\" and \"dependentRequired\"","type":"object","additionalProperties":{"anyOf":[{"$recursiveRef":"#"},{"$ref":"meta/validation#/$defs/stringArray"}]}}}}],
   ["https://json-schema.org/draft/2019-09/meta/core", {"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/core","$recursiveAnchor":true,"title":"Core vocabulary meta-schema","type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference","$comment":"Non-empty fragments not allowed.","pattern":"^[^#]*#?$"},"$schema":{"type":"string","format":"uri"},"$anchor":{"type":"string","pattern":"^[A-Za-z][-A-Za-z0-9.:_]*$"},"$ref":{"type":"string","format":"uri-reference"},"$recursiveRef":{"type":"string","format":"uri-reference"},"$recursiveAnchor":{"type":"boolean","default":false},"$vocabulary":{"type":"object","propertyNames":{"type":"string","format":"uri"},"additionalProperties":{"type":"boolean"}},"$comment":{"type":"string"},"$defs":{"type":"object","additionalProperties":{"$recursiveRef":"#"},"default":{}}}}],

package/lib/plan-compiler.js

@@ -53,7 +53,7 @@ const branchTitle = (n) => (n && n.schema && typeof n.schema.title === 'string'
 function install(deps) {
   const { Plan, NOERRORS, err, evalLeaf, evalLeafV, runCustomV, dataBits, escapePointer,
           deepEqual, enumMember, allDistinct, multipleOfOk, cpAtLeast, cpAtMost,
-          T_STRING, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri } = deps;
+          T_STRING, T_NUMBER, T_INTEGER, T_BOOLEAN, T_NULL, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri } = deps;
 
   const TRUE_FN = () => true;
   // `leaf`: the node compiled no subschema of its own (see compileNode). A
@@ -169,12 +169,21 @@ function install(deps) {
     }
     if (P.enum !== null) {
       if (P.enum.length === 0) checks.push(() => false);
+      else if (P.enumObjs.length === 0) { const prims = P.enumPrims; checks.push((data) => prims.has(data)); }
       else checks.push((data) => enumMember(P, data));
     }
     if (P.hasConst) {
       const c = P.const;
       checks.push((data) => deepEqual(c, data));
     }
+    // The value checks of each type, folded to one call or null. A node of
+    // one type and nothing but that type's keywords (the common leaf: a
+    // string with a length, an integer with a bound) is answered by one
+    // closure over typeof and that call, with no type bits computed and no
+    // chain of guarded checks: the interpreted engine spent a fifth of a
+    // document in those calls.
+    const reqFolded = P.required !== null && P.requiredUndef === null && P.properties !== null;
+    let numsRun = null;
     if (P.hasNumber) {
       const nums = [];
       if (P.minimum !== undefined) { const m = P.minimum; nums.push((d) => d >= m); }
@@ -182,42 +191,45 @@ function install(deps) {
       if (P.exclusiveMinimum !== undefined) { const m = P.exclusiveMinimum; nums.push((d) => d > m); }
       if (P.exclusiveMaximum !== undefined) { const m = P.exclusiveMaximum; nums.push((d) => d < m); }
       if (P.multipleOf !== undefined) { const m = P.multipleOf; nums.push((d) => multipleOfOk(d, m)); }
-      const run = combineValue(nums);
-      // A non-finite number is not of type `number` here: dataBits() gives it
-      // no type bit, and an empty schema accepts it. So the numeric keywords
-      // must not apply to it either, or `{ minimum: 3 }` rejects a value that
-      // `{}` accepts and the compiled engine admits.
-      if (run !== null) checks.push((data) => !Number.isFinite(data) || run(data));
+      numsRun = combineValue(nums);
     }
+    let strsRun = null;
     if (P.hasString) {
       const strs = [];
-      if (P.minLength !== undefined) { const m = P.minLength; strs.push((d) => cpAtLeast(d, m)); }
-      if (P.maxLength !== undefined) { const m = P.maxLength; strs.push((d) => cpAtMost(d, m)); }
+      if (P.minLength !== undefined && P.maxLength !== undefined) {
+        const lo = P.minLength, hi = P.maxLength;
+        strs.push((d) => { const n = d.length; return (n >= 2 * lo && n <= hi) || (cpAtLeast(d, lo) && cpAtMost(d, hi)); });
+      } else if (P.minLength !== undefined) { const m = P.minLength; strs.push((d) => cpAtLeast(d, m)); }
+      else if (P.maxLength !== undefined) { const m = P.maxLength; strs.push((d) => cpAtMost(d, m)); }
       if (P.pattern !== null) { const re = P.pattern; strs.push((d) => re.test(d)); }
       if (P.formatFn !== null) { const f = P.formatFn; strs.push((d) => f(d)); }
-      const run = combineValue(strs);
-      if (run !== null) { needsBits = true; checks.push((data, bits) => bits !== T_STRING || run(data)); }
+      strsRun = combineValue(strs);
     }
-    // `hasArray` also covers prefixItems/items/contains, which are not leaf
-    // keywords; only the three value-level ones belong here, exactly as
-    // evalLeafV() reads them.
+    let arrsRun = null;
     if (P.minItems !== undefined || P.maxItems !== undefined || P.uniqueItems) {
       const arrs = [];
       if (P.minItems !== undefined) { const m = P.minItems; arrs.push((d) => d.length >= m); }
       if (P.maxItems !== undefined) { const m = P.maxItems; arrs.push((d) => d.length <= m); }
       if (P.uniqueItems) arrs.push(allDistinct);
-      const run = combineValue(arrs);
-      if (run !== null) { needsBits = true; checks.push((data, bits) => bits !== T_ARRAY || run(data)); }
+      arrsRun = combineValue(arrs);
     }
-    if (P.required !== null || P.minProperties !== undefined || P.maxProperties !== undefined || P.dependentRequired !== null) {
+    let objsRun = null;
+    if ((P.required !== null && !reqFolded) || P.minProperties !== undefined || P.maxProperties !== undefined || P.dependentRequired !== null) {
       const objs = [];
-      if (P.required !== null) {
+      if (P.required !== null && !reqFolded) {
         const req = P.required;
-        if (req.length === 1) { const k = req[0]; objs.push((d) => Object.hasOwn(d, k)); }
-        else objs.push((d) => {
+        // A required key holding undefined is missing; for a declared
+        // property the property step finds it (requiredInProps).
+        const undef = P.requiredUndef;
+        if (req.length === 1) { const k = req[0]; objs.push(undef !== null && undef[0] ? (d) => Object.hasOwn(d, k) && d[k] !== undefined : (d) => Object.hasOwn(d, k)); }
+        else if (undef === null) objs.push((d) => {
           for (let i = 0; i < req.length; i++) if (!Object.hasOwn(d, req[i])) return false;
           return true;
         });
+        else objs.push((d) => {
+          for (let i = 0; i < req.length; i++) if (!Object.hasOwn(d, req[i]) || (undef[i] && d[req[i]] === undefined)) return false;
+          return true;
+        });
       }
       if (P.minProperties !== undefined) { const m = P.minProperties; objs.push((d) => Object.keys(d).length >= m); }
       if (P.maxProperties !== undefined) { const m = P.maxProperties; objs.push((d) => Object.keys(d).length <= m); }
@@ -232,9 +244,34 @@ function install(deps) {
           return true;
         });
       }
-      const run = combineValue(objs);
-      if (run !== null) { needsBits = true; checks.push((data, bits) => bits !== T_OBJECT || run(data)); }
+      objsRun = combineValue(objs);
     }
+    if (P.hasType && P.enum === null && !P.hasConst && !P.hasCustom && checks.length === 1) {
+      const m = P.typeMask;
+      // The run of the type's own keywords, and whether any other type's are present.
+      const own = m === T_STRING ? strsRun : m === T_INTEGER || m === T_NUMBER ? numsRun : m === T_OBJECT ? objsRun : m === T_ARRAY ? arrsRun : null;
+      const foreign = (numsRun !== null && m !== T_INTEGER && m !== T_NUMBER) || (strsRun !== null && m !== T_STRING) || (arrsRun !== null && m !== T_ARRAY) || (objsRun !== null && m !== T_OBJECT);
+      if (!foreign) {
+        const r = own;
+        switch (m) {
+          case T_STRING: return r === null ? (d) => typeof d === 'string' : (d) => typeof d === 'string' && r(d);
+          case T_INTEGER: return r === null ? (d) => Number.isInteger(d) : (d) => Number.isInteger(d) && r(d);
+          case T_NUMBER: return r === null ? (d) => typeof d === 'number' && isFinite(d) : (d) => typeof d === 'number' && isFinite(d) && r(d);
+          case T_BOOLEAN: return (d) => typeof d === 'boolean';
+          case T_NULL: return (d) => d === null;
+          case T_OBJECT: return r === null ? (d) => typeof d === 'object' && d !== null && !Array.isArray(d) : (d) => typeof d === 'object' && d !== null && !Array.isArray(d) && r(d);
+          case T_ARRAY: return r === null ? (d) => Array.isArray(d) : (d) => Array.isArray(d) && r(d);
+        }
+      }
+    }
+    // A non-finite number is not of type `number` here: dataBits() gives it
+    // no type bit, and an empty schema accepts it. So the numeric keywords
+    // must not apply to it either, or `{ minimum: 3 }` rejects a value that
+    // `{}` accepts and the compiled engine admits.
+    if (numsRun !== null) { const run = numsRun; checks.push((data) => !Number.isFinite(data) || run(data)); }
+    if (strsRun !== null) { const run = strsRun; needsBits = true; checks.push((data, bits) => bits !== T_STRING || run(data)); }
+    if (arrsRun !== null) { const run = arrsRun; needsBits = true; checks.push((data, bits) => bits !== T_ARRAY || run(data)); }
+    if (objsRun !== null) { const run = objsRun; needsBits = true; checks.push((data, bits) => bits !== T_OBJECT || run(data)); }
 
     if (P.hasCustom) {
       needsBits = true;
@@ -310,6 +347,7 @@ function install(deps) {
 
     const steps = [];   // collect variant: (data, errors, ip, sp, stack, rec)
     const vsteps = [];  // verdict variant: (data, stack, rec)
+    let leafV = TRUE_FN;
 
     // $ref / $dynamicRef, resolved at compile time.
     for (let which = 0; which < 2; which++) {
@@ -385,7 +423,8 @@ function install(deps) {
         P.required !== null || P.minProperties !== undefined || P.maxProperties !== undefined ||
         P.dependentRequired !== null || P.hasCustom) {
       steps.push((data, errors, instancePath, schemaPath) => evalLeaf(P, data, errors, instancePath, schemaPath));
-      vsteps.push(compileLeafV(P));
+      leafV = compileLeafV(P);
+      if (leafV !== TRUE_FN) vsteps.push(leafV);
     }
 
     // Arrays
@@ -490,8 +529,10 @@ function install(deps) {
       // Declared properties: a linear scan over a short list beats a Map
       // lookup, and most schemas declare a handful.
       const propKeys = props !== null ? [...props.keys()] : null;
+      // req: the key is also required, so holding undefined it is missing.
+      const reqIn = P.requiredInProps;
       const propList = props !== null
-        ? [...props.values()].map((entry) => ({ fn: child(entry.node), seg: entry.seg, schemaSeg: entry.schemaSeg }))
+        ? [...props].map(([key, entry]) => ({ fn: child(entry.node), seg: entry.seg, schemaSeg: entry.schemaSeg, req: reqIn !== null && reqIn.has(key) }))
         : null;
       const propMap = props !== null && props.size > 8 ? new Map(propKeys.map((k, i) => [k, propList[i]])) : null;
       const lookup = propMap !== null
@@ -503,6 +544,10 @@ function install(deps) {
         ? P.patternProperties.map((e) => ({ re: e.re, src: e.src, fn: child(e.node) }))
         : null;
       const apFn = P.additionalProperties !== undefined ? child(P.additionalProperties) : null;
+      // The node's value checks, when they are the step before this one,
+      // run inside it: one closure call per object instead of two, and the
+      // composition above it goes away.
+      const fusedLeaf = vsteps.length > 0 && vsteps[vsteps.length - 1] === leafV && leafV !== TRUE_FN ? vsteps.pop() : null;
       // `additionalProperties: false` is a boolean subschema, but its error is
       // not the generic "boolean schema is false": every consumer switches on
       // keyword === 'additionalProperties' and reads params.additionalProperty
@@ -533,12 +578,18 @@ function install(deps) {
           let evaluated = false;
           const prop = lookup !== null ? lookup(key) : undefined;
           // A declared property whose value is undefined is not checked (see
-          // the interpreter's eval).
+          // the interpreter's eval); required, it is missing.
           if (prop !== undefined) {
             const value = data[key];
-            if (value !== undefined && !((prop.fn.leaf && prop.fn.v(value, stack)) || prop.fn.c(value, errors, instancePath + prop.seg, schemaPath + prop.schemaSeg, stack))) {
+            if (value !== undefined) {
+              if (!((prop.fn.leaf && prop.fn.v(value, stack)) || prop.fn.c(value, errors, instancePath + prop.seg, schemaPath + prop.schemaSeg, stack))) {
+                ok = false;
+                if (errors === NOERRORS) return false;
+              }
+            } else if (prop.req) {
               ok = false;
               if (errors === NOERRORS) return false;
+              errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`));
             }
             evaluated = true;
           }
@@ -576,30 +627,58 @@ function install(deps) {
         // not mistaken for data. A long list walks the data's keys instead,
         // since the data usually carries far fewer.
         const n = propKeys.length;
+        // On an ordinary object (its prototype is Object.prototype) a key
+        // that names nothing on that prototype is read directly: a value
+        // means the key is the object's own, undefined means absent or held
+        // undefined, which the schema treats alike. Other objects, and keys
+        // such as `constructor` or `toString`, keep the own-property test.
+        const direct = propKeys.map((k) => !(k in Object.prototype));
+        const assertsObject = fusedLeaf !== null && P.hasType && P.typeMask === T_OBJECT;
         vsteps.push((data, stack, rec) => {
-          if (dataBits(data) !== T_OBJECT) return true;
+          if (fusedLeaf !== null && !fusedLeaf(data)) return false;
+          if (!assertsObject && dataBits(data) !== T_OBJECT) return true;
+          const plain = Object.getPrototypeOf(data) === Object.prototype;
           for (let i = 0; i < n; i++) {
             const key = propKeys[i];
-            if (!Object.hasOwn(data, key)) continue;
-            const value = data[key];
-            if (value !== undefined && !propList[i].fn.v(value, stack)) return false;
+            let value;
+            if (plain && direct[i]) {
+              value = data[key];
+              // Absent or held undefined: missing when required (the leaf
+              // step no longer checks it, reqFolded in compileLeafV). A key
+              // held undefined still counts as evaluated for the record.
+              if (value === undefined) { if (propList[i].req) return false; if (collect && Object.hasOwn(data, key)) addProp(rec, key); continue; }
+            } else {
+              if (!Object.hasOwn(data, key)) { if (propList[i].req) return false; continue; }
+              value = data[key];
+              if (value === undefined) { if (propList[i].req) return false; if (collect) addProp(rec, key); continue; }
+            }
+            if (!propList[i].fn.v(value, stack)) return false;
             if (collect) addProp(rec, key);
           }
           return true;
         });
-      } else vsteps.push((data, stack, rec) => {
+      } else {
+        // Required keys that are declared properties are counted as the walk
+        // meets them (reqFolded in compileLeafV); one short at the end means
+        // one is missing.
+        const reqN = P.required !== null && P.requiredUndef === null && P.requiredInProps !== null ? P.requiredInProps.size : 0;
+        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);
         if (pnFn !== null) {
           for (const k of keys) if (!pnFn.v(k, stack)) return false;
         }
+        let seenReq = 0;
         for (let k = 0; k < keys.length; k++) {
           const key = keys[k];
           let evaluated = false;
           const prop = lookup !== null ? lookup(key) : undefined;
           if (prop !== undefined) {
             const value = data[key];
-            if (value !== undefined && !prop.fn.v(value, stack)) return false;
+            if (value !== undefined) { if (!prop.fn.v(value, stack)) return false; }
+            else if (prop.req) return false;
+            if (prop.req) seenReq++;
             evaluated = true;
           }
           if (patterns !== null) {
@@ -617,8 +696,9 @@ function install(deps) {
           }
           if (evaluated && collect) addProp(rec, key);
         }
-        return true;
+        return seenReq === reqN;
       });
+      }
     }
     if (P.dependentSchemas !== null) {
       const entries = P.dependentSchemas.map(([k, v]) => [k, inPlace(v, base), escapePointer(k)]);

package/lib/regex-linear.js

@@ -210,6 +210,86 @@ function deterministicRule (ast) {
   return unbounded === 0 || anchored(ast)
 }
 
+// Two more shapes the rules above decline, both anchored with `^` and `$`
+// around one top-level sequence.
+//
+// One choice: characters and classes, each repeated a fixed or bounded number
+// of times, with only one of the repeats able to vary, by at most 256
+// (`^[a-z0-9_-]{1,128}$`).
+// The engine backtracks through that one repeat and nowhere else, at most its
+// width per attempt, and the anchor allows one attempt.
+//
+// A delimited loop: `^P(Xd)*Q$` or with `+`, where d is one character or
+// class, X and Q match nothing d matches (Q may end with d, or an optional
+// d), and P holds no unbounded quantifier. Dotted identifiers and paths are
+// written so: `^([A-Za-z_$][\w$]*\.)*[A-Za-z_$][\w$]*$`, `^/?([^/]+/)*[^/]+/?$`.
+// Every iteration and Q's match end at a d or at the end, so each wrong
+// choice between another iteration and Q fails within one segment, and the
+// segments together are the input once. X and Q each hold at most one
+// unbounded quantifier, over a character or class, so a segment is not split
+// two ways either.
+function sequenceOf (ast) {
+  if (ast.t !== 'concat') return null
+  const parts = ast.parts
+  if (parts.length < 3 || parts[0].t !== 'bol' || parts[parts.length - 1].t !== 'eol') return null
+  return parts.slice(1, -1)
+}
+const repeatOfAtom = (n) => (n.t === 'star' || n.t === 'plus' || n.t === 'quest' || n.t === 'repeat') && atom(n.child)
+const unboundedNode = (n) => n.t === 'star' || n.t === 'plus' || (n.t === 'repeat' && n.max === Infinity)
+
+function oneChoiceRule (ast) {
+  const seq = sequenceOf(ast)
+  if (seq === null) return false
+  let varying = 0
+  for (const n of seq) {
+    if (atom(n)) continue
+    if (n.t === 'repeat' && atom(n.child) && n.max !== Infinity) {
+      if (n.max > 256) return false
+      if (n.max > n.min) varying++
+      continue
+    }
+    return false
+  }
+  return varying <= 1
+}
+
+function delimitedLoopRule (ast) {
+  const seq = sequenceOf(ast)
+  if (seq === null) return false
+  const loopAt = seq.findIndex((n) => unboundedNode(n) && !atom(n.child))
+  if (loopAt < 0) return false
+  let body = seq[loopAt].child
+  while (body.t === 'group') body = body.child
+  if (body.t !== 'concat' || body.parts.length < 2) return false
+  const d = body.parts[body.parts.length - 1]
+  if (!atom(d)) return false
+  const D = charSet(d)
+  // A run of characters, classes and their repeats that matches nothing in
+  // D, with at most one unbounded quantifier.
+  const run = (nodes) => {
+    let unbounded = 0
+    for (const n of nodes) {
+      const a = atom(n) ? n : repeatOfAtom(n) ? n.child : null
+      if (a === null || overlap(charSet(a), D)) return false
+      if (unboundedNode(n)) unbounded++
+      if (n.t === 'repeat' && n.max !== Infinity && n.max - n.min > 64) return false
+    }
+    return unbounded <= 1
+  }
+  if (!run(body.parts.slice(0, -1))) return false
+  const prefix = seq.slice(0, loopAt)
+  if (prefix.some(hasUnbounded)) return false
+  const pb = simpleRule({ t: 'concat', parts: prefix })
+  if (!pb && prefix.length > 0) return false
+  let suffix = seq.slice(loopAt + 1)
+  const last = suffix[suffix.length - 1]
+  if (last !== undefined) {
+    const tail = atom(last) ? last : last.t === 'quest' && atom(last.child) ? last.child : null
+    if (tail !== null && !overlap(charSet(tail), { bits: D.bits.map((b) => b ^ 1), high: D.high ? 0 : 1 })) suffix = suffix.slice(0, -1)
+  }
+  return run(suffix)
+}
+
 function nativeIsLinear (src) {
   if (typeof src !== 'string' || src.length > 512) return false
   for (let i = 0; i < src.length; i++) {
@@ -225,7 +305,7 @@ function nativeIsLinear (src) {
   }
   let ast
   try { ast = parse(src) } catch { return false }
-  return simpleRule(ast) || deterministicRule(ast)
+  return simpleRule(ast) || deterministicRule(ast) || oneChoiceRule(ast) || delimitedLoopRule(ast)
 }
 
 module.exports = { nativeIsLinear }

package/lib/safe-regex.js

@@ -473,25 +473,28 @@ function __ataSafeRegex () {
       }
       if (id < 0) return testNFA(s)
       if (len === 0) return (flags[id] & 1) === 1
-      // The last character is stepped with the end-of-input flag set and is
-      // handled after the loop, so the loop body selects no table and tests
-      // no position.
+      if ((flags[id] & 1) === 1) return true
+      // The last character, with the end flag, is stepped after the loop.
+      // Tables are locals, reread after `step` (which may grow them).
       const last = len - 1
+      let T = trans
+      let F = flags
       for (let pos = 0; pos < last; pos++) {
-        if ((flags[id] & 1) === 1) return true
         const c = s.charCodeAt(pos)
-        let nid
-        if (c < 128) {
-          nid = trans[(id << 7) | c]
-          if (nid === -2) { nid = step(states[id], c, false); if (nid >= 0 || overflow) trans[(id << 7) | c] = nid }
-        } else {
+        let nid = c < 128 ? T[(id << 7) | c] : -2
+        if (nid === -2) {
           nid = step(states[id], c, false)
+          T = trans; F = flags
+          if (c < 128 && (nid >= 0 || overflow)) T[(id << 7) | c] = nid
         }
         if (nid < 0) return testNFA(s)
         id = nid
-        if ((flags[id] & 2) === 2) return false
+        const f = F[id]
+        if (f !== 0) {
+          if ((f & 2) === 2) return false
+          return true
+        }
       }
-      if ((flags[id] & 1) === 1) return true
       const c = s.charCodeAt(last)
       let nid
       if (c < 128) {

package/lib/schema-scan.js

@@ -30,23 +30,10 @@ const TUPLE_ITEMS = 1 << 5;      // array-valued `items`, split into `prefixItem
 const EXCLUSIVE_BOOL = 1 << 6;   // draft-04's boolean `exclusiveMinimum`/`exclusiveMaximum`
 const ENCODED_REF = 1 << 7;      // a fragment `$ref` holding a percent escape, decoded by normalizeNullable's walk
 
-// Questions compat asks of a schema it is about to compile (compat.js), read
-// on the same walk so that a document is not walked again for them.
-const HAS_REF = 1 << 8;          // `$ref` anywhere
-const BEYOND_ITEMS = 1 << 9;     // a subschema keyword other than `properties` and object `items`
-const DISCRIMINATOR = 1 << 10;   // `discriminator` anywhere
-const HAS_DEFAULT = 1 << 11;     // `default` anywhere
-const HAS_ALLOF = 1 << 12;       // `allOf` anywhere
-const HAS_FORMAT = 1 << 13;      // `format` anywhere
-const KEY_BITS = new Map([
-  ['$ref', HAS_REF | BEYOND_ITEMS], ['$dynamicRef', BEYOND_ITEMS], ['allOf', HAS_ALLOF | BEYOND_ITEMS],
-  ['anyOf', BEYOND_ITEMS], ['oneOf', BEYOND_ITEMS], ['not', BEYOND_ITEMS], ['if', BEYOND_ITEMS],
-  ['then', BEYOND_ITEMS], ['else', BEYOND_ITEMS], ['additionalProperties', BEYOND_ITEMS],
-  ['patternProperties', BEYOND_ITEMS], ['prefixItems', BEYOND_ITEMS], ['additionalItems', BEYOND_ITEMS],
-  ['contains', BEYOND_ITEMS], ['dependentSchemas', BEYOND_ITEMS], ['dependencies', BEYOND_ITEMS],
-  ['propertyNames', BEYOND_ITEMS], ['unevaluatedProperties', BEYOND_ITEMS], ['unevaluatedItems', BEYOND_ITEMS],
-  ['discriminator', DISCRIMINATOR], ['default', HAS_DEFAULT], ['format', HAS_FORMAT],
-]);
+// Questions compat asks of a schema it is about to compile, read on the same
+// walk so that a document is not walked again for them. compat sets the keys
+// and their bits (setExtraKeys); without compat the walk reads none.
+let EXTRA = null;
 
 // Everything only draft-07 normalization acts on. A schema of another dialect
 // can carry these without them meaning anything, so they are read together
@@ -71,7 +58,7 @@ const ANCHOR_ID_RE = /^#[A-Za-z][A-Za-z0-9_.:-]*$/;
 // This assumes a schema is not mutated after being handed to a Validator,
 // which is already true of everything else here: the compile cache, the
 // identity cache and the schema map would all be stale too.
-const CACHE = new WeakMap();
+let CACHE = new WeakMap();
 
 function scan(schema) {
   if (typeof schema !== 'object' || schema === null) return 0;
@@ -110,11 +97,13 @@ function scan(schema) {
     }
     // Every key, not just the subschema keywords, so this cannot miss a place
     // the normalizers would reach.
-    for (let i = 0; i < keys.length; i++) {
-      const b = KEY_BITS.get(keys[i]);
-      if (b !== undefined) bits |= b;
-      walk(node[keys[i]]);
+    if (EXTRA !== null) {
+      for (let i = 0; i < keys.length; i++) {
+        const b = EXTRA.get(keys[i]);
+        if (b !== undefined) bits |= b;
+      }
     }
+    for (let i = 0; i < keys.length; i++) walk(node[keys[i]]);
   };
 
   walk(schema);
@@ -146,10 +135,12 @@ module.exports = {
   EXCLUSIVE_BOOL,
   ENCODED_REF,
   DRAFT7_WORK,
-  HAS_REF,
-  BEYOND_ITEMS,
-  DISCRIMINATOR,
-  HAS_DEFAULT,
-  HAS_ALLOF,
-  HAS_FORMAT,
 };
+
+// A schema scanned before the keys were set is scanned again: what was
+// remembered for it does not answer the new questions.
+function setExtraKeys(map) {
+  EXTRA = map;
+  CACHE = new WeakMap();
+}
+Object.defineProperty(module.exports, '_setExtraKeys', { value: setExtraKeys, enumerable: false });

package/lib/tier0.js

@@ -173,6 +173,7 @@ function tier0ValidateObject(plan, data) {
     // 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) {
+      // A required key holding undefined is missing, as in every engine.
       if (reqMask & (1 << i)) return false;
       continue;
     }

package/lib/unique-items.js

@@ -22,17 +22,28 @@ function _deq(a, b) {
   if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
   var aa = Array.isArray(a);
   if (aa !== Array.isArray(b)) return false;
-  var i;
+  var i, k, x, y;
   if (aa) {
     if (a.length !== b.length) return false;
-    for (i = 0; i < a.length; i++) if (!_deq(a[i], b[i])) return false;
+    for (i = a.length; i-- !== 0;) if (!_deq(a[i], b[i])) return false;
     return true;
   }
   var ka = Object.keys(a);
   if (ka.length !== Object.keys(b).length) return false;
-  for (i = 0; i < ka.length; i++) {
-    var k = ka[i];
-    if (!Object.prototype.hasOwnProperty.call(b, k) || !_deq(a[k], b[k])) return false;
+  // Keys and scalar values first, nested values after, from the last key back:
+  // two items of a list most often differ in a name, a path or an id, and
+  // walking a nested list first made each comparison of rust-project's crates
+  // three times what it needed (250 against 78 ns for the three; the default
+  // validator's deep equal takes 115).
+  for (i = ka.length; i-- !== 0;) {
+    k = ka[i];
+    if (!Object.prototype.hasOwnProperty.call(b, k)) return false;
+    x = a[k]; y = b[k];
+    if (x !== y && (x === null || y === null || typeof x !== 'object' || typeof y !== 'object')) return false;
+  }
+  for (i = ka.length; i-- !== 0;) {
+    k = ka[i]; x = a[k];
+    if (x !== null && typeof x === 'object' && !_deq(x, b[k])) return false;
   }
   return true;
 }