@jarenjs/validate 0.9.2 → 0.34.2

package/src/object.js

@@ -62,6 +62,9 @@ function compileRequiredProperties(schemaObj, jsonSchema) {
   /** @type {function(string, any, string):boolean} */
   // Use array key to get keyed error handler: addKeyedError(dataKey, data, ...meta)
   const addError = schemaObj.createErrorHandler(required, ['required']);
+  // When errors are recorded, every missing property must produce one; only
+  // the boolean-answer path may stop at the first.
+  const stopAtFirst = schemaObj.root.options.skipErrors;
   return function validateRequiredProperties(data = {}, dataKeys = [], dataPath = '') {
     if (!(dataKeys.length > 0))
       return false;
@@ -70,8 +73,10 @@ function compileRequiredProperties(schemaObj, jsonSchema) {
     for (let i = 0; i < rlength; ++i) {
       const key = required[i];
       const idx = dataKeys.indexOf(key);
-      if (idx === -1)
-        valid &&= addError(key, data, dataPath);
+      if (idx === -1) {
+        valid = addError(key, data, dataPath) && valid;
+        if (stopAtFirst) break;
+      }
     }
     return valid;
   };
@@ -84,8 +89,10 @@ function compilePropertyNames(schemaObj, jsonSchema) {
   if (propNames == null) return undefined;
 
   const propertyNamesValidator = schemaObj.createValidator(propNames, 'propertyNames');
-  return function validatePropertyNames(dataKey) {
-    return propertyNamesValidator(dataKey);
+  // The property NAME is the validated data; the object's data path is
+  // threaded through so name failures report a usable instancePath.
+  return function validatePropertyNames(dataKey, dataPath) {
+    return propertyNamesValidator(dataKey, dataPath);
   }
 }
 
@@ -185,7 +192,7 @@ function compileAdditionalProperties(schemaObj, jsonSchema) {
     const addError = schemaObj.createErrorHandler(false, ['additionalProperties']);
 
     return function validateNoAdditionalProperties(data, dataPath, dataRoot, dataKey) {
-      return addError(dataKey, data);
+      return addError(dataKey, data, dataPath);
     };
   }
 
@@ -216,13 +223,15 @@ function compileDependentRequired(schemaObj, jsonSchema) {
   if (Object.keys(dependentRequired).length === 0)
     return undefined;
 
-  const addError = schemaObj.createErrorHandler(false, 'dependentRequired');
+  // Keyed handler: addError(dataKey, data, dataPath) - dataKey names the
+  // triggering property, rest[0] is the instance data path.
+  const addError = schemaObj.createErrorHandler(false, ['dependentRequired']);
 
   return function validateDependentRequiredItem(data, dataPath, dataRoot, dataKey) {
     if (dataKey in dependentRequired) {
       const required = dependentRequired[dataKey];
       return includesAll(Object.keys(data), required)
-        || addError(data, dataKey, dataPath);
+        || addError(dataKey, data, dataPath);
     }
     return true;
   };
@@ -320,7 +329,7 @@ function compileDependencies(schemaObj, jsonSchema) {
         const dataKeys = Object.keys(data);
         for (let i = 0; i < rlen; i++) {
           if (!dataKeys.includes(required[i])) {
-            return addError(data, dataKey, dataPath);
+            return addError(dataKey, data, dataPath);
           }
         }
       }
@@ -350,7 +359,7 @@ function compileDependencies(schemaObj, jsonSchema) {
     if (reqDep != null) {
       const { required, addError } = reqDep;
       return includesAll(Object.keys(data), required)
-        || addError(data, dataKey, dataPath);
+        || addError(dataKey, data, dataPath);
     }
     return true;
   };
@@ -382,6 +391,9 @@ export function compileObjectPrimitives(schemaObj, jsonSchema) {
   const hasMin = min > 0;
   const hasMax = max != null && max >= 0;
   const hasRequired = required != null && required.length > 0;
+  // When errors are recorded, every missing required property must produce
+  // one; only the boolean-answer path may stop at the first.
+  const stopAtFirst = schemaObj.root.options.skipErrors;
 
   // Pre-bind error handlers outside the returned function
   if (hasMin && !hasMax && !hasRequired) {
@@ -414,6 +426,25 @@ export function compileObjectPrimitives(schemaObj, jsonSchema) {
   if (!hasMin && !hasMax && hasRequired) {
     const rlength = required.length;
     const addError = schemaObj.createErrorHandler(required, ['required']);
+    // Non-string entries (invalid schemas) can never match a data key;
+    // they stay on the Object.keys path below.
+    if (required.every(key => typeof key === 'string')) {
+      return function validateRequiredHasOwn(data, dataPath, _dataRoot, _dataKeys) {
+        // Required properties only apply to objects, not arrays or other types
+        if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+          return true;
+        }
+        let valid = true;
+        for (let i = 0; i < rlength; ++i) {
+          const key = required[i];
+          if (!Object.hasOwn(data, key)) {
+            valid = addError(key, data, dataPath) && valid;
+            if (stopAtFirst) break;
+          }
+        }
+        return valid;
+      };
+    }
     return function validateRequiredOnly(data, dataPath, dataRoot, dataKeys) {
       // Required properties only apply to objects, not arrays or other types
       if (typeof data !== 'object' || data === null || Array.isArray(data)) {
@@ -423,8 +454,10 @@ export function compileObjectPrimitives(schemaObj, jsonSchema) {
       let valid = true;
       for (let i = 0; i < rlength; ++i) {
         const key = required[i];
-        if (keys.indexOf(key) === -1)
-          valid &&= addError(key, data, dataPath);
+        if (keys.indexOf(key) === -1) {
+          valid = addError(key, data, dataPath) && valid;
+          if (stopAtFirst) break;
+        }
       }
       return valid;
     };
@@ -441,15 +474,19 @@ export function compileObjectPrimitives(schemaObj, jsonSchema) {
       }
       const keys = dataKeys || Object.keys(data);
       const len = keys.length;
-      if (len < min && !addMinError(len, dataPath))
-        return false;
+      // minProperties and required are independent; a short count says
+      // nothing about WHICH members are missing, which is the useful half.
+      let sizeOk = len >= min || addMinError(len, dataPath);
+      if (stopAtFirst && !sizeOk) return false;
       let valid = true;
       for (let i = 0; i < rlength; ++i) {
         const key = required[i];
-        if (keys.indexOf(key) === -1)
-          valid &&= addReqError(key, data, dataPath);
+        if (keys.indexOf(key) === -1) {
+          valid = addReqError(key, data, dataPath) && valid;
+          if (stopAtFirst) break;
+        }
       }
-      return valid;
+      return sizeOk && valid;
     };
   }
 
@@ -464,15 +501,18 @@ export function compileObjectPrimitives(schemaObj, jsonSchema) {
       }
       const keys = dataKeys || Object.keys(data);
       const len = keys.length;
-      if (len > max && !addMaxError(len, dataPath))
-        return false;
+      // maxProperties and required are independent (see the min case).
+      let sizeOk = len <= max || addMaxError(len, dataPath);
+      if (stopAtFirst && !sizeOk) return false;
       let valid = true;
       for (let i = 0; i < rlength; ++i) {
         const key = required[i];
-        if (keys.indexOf(key) === -1)
-          valid &&= addReqError(key, data, dataPath);
+        if (keys.indexOf(key) === -1) {
+          valid = addReqError(key, data, dataPath) && valid;
+          if (stopAtFirst) break;
+        }
       }
-      return valid;
+      return sizeOk && valid;
     };
   }
 
@@ -484,9 +524,16 @@ export function compileObjectPrimitives(schemaObj, jsonSchema) {
   return function validateObjectPrimitives(data, dataPath, dataRoot, dataKeys) {
     const keys = dataKeys || Object.keys(data);
     const len = keys.length;
-    return isMinProperties(len, dataPath)
-      && isMaxProperties(len, dataPath)
-      && hasRequiredProperties(data, keys, dataPath);
+    if (stopAtFirst) {
+      return isMinProperties(len, dataPath)
+        && isMaxProperties(len, dataPath)
+        && hasRequiredProperties(data, keys, dataPath);
+    }
+    // min/max/required are three independent assertions about the same
+    // object; each is the only thing that can report its own fault.
+    let valid = isMinProperties(len, dataPath);
+    valid = isMaxProperties(len, dataPath) && valid;
+    return hasRequiredProperties(data, keys, dataPath) && valid;
   };
 }
 
@@ -521,7 +568,7 @@ function compileObjectProperty(schemaObj, jsonSchema) {
     // Build the child dataPath by appending the property key
     const newPath = dataPath ? `${dataPath}/${dataKey}` : `/${dataKey}`;
 
-    result.addValid(validateName(dataKey))
+    result.addValid(validateName(dataKey, dataPath))
       .addResult(validateProperty(data, newPath, dataRoot, dataKey))
       .addResult(validatePattern(data, newPath, dataRoot, dataKey))
       .addValid(validateDepRequired(data, newPath, dataRoot, dataKey))
@@ -584,7 +631,7 @@ function compileObjectChildrenFast(schemaObj, jsonSchema) {
     const len = dataKeys.length;
     for (let i = 0; i < len; ++i) {
       const dataKey = dataKeys[i];
-      if (validateName != null && validateName(dataKey) === false)
+      if (validateName != null && validateName(dataKey, dataPath) === false)
         return false;
 
       let matched = false;
@@ -675,9 +722,10 @@ export function compileObjectSchema(schemaObj, jsonSchema) {
   if (isOfSchemaType(jsonSchema, 'map'))
     return undefined;
 
-  // Fast path: properties-only schema in skipErrors mode. Iterate the
-  // (fixed) schema keys with direct property access instead of allocating
-  // Object.keys(data) and doing a map lookup per data key.
+  // Fast path: properties(+required)-only schema in skipErrors mode.
+  // Iterate the (fixed) schema keys with direct property access instead of
+  // allocating Object.keys(data) and doing a map lookup per data key;
+  // required membership is a per-key Object.hasOwn probe.
   if (schemaObj.options.skipErrors
     && jsonSchema.patternProperties == null
     && jsonSchema.additionalProperties == null
@@ -687,12 +735,21 @@ export function compileObjectSchema(schemaObj, jsonSchema) {
     && jsonSchema.dependentRequired == null
     && jsonSchema.minProperties == null
     && jsonSchema.maxProperties == null
-    && jsonSchema.required == null
+    && (jsonSchema.required == null
+      || (isArrayClass(jsonSchema.required)
+        && jsonSchema.required.every(key => typeof key === 'string')))
     && getObjectType(jsonSchema.properties) != null) {
     const propsMap = buildPropertyValidators(schemaObj, jsonSchema);
     if (propsMap == null)
       return undefined;
 
+    // required belongs to the validation vocabulary; assert nothing when
+    // the metaschema disables it.
+    const requiredKeys = schemaObj.options.vocabValidation !== false
+      ? getArrayClassMinItems(jsonSchema.required, 1) || null
+      : null;
+    const requiredCount = requiredKeys === null ? 0 : requiredKeys.length;
+
     const propKeys = Array.from(propsMap.keys());
     const propValidators = Array.from(propsMap.values());
     const propCount = propKeys.length;
@@ -706,6 +763,10 @@ export function compileObjectSchema(schemaObj, jsonSchema) {
       const extendPaths = root.usesDollarData;
       return function validateObjectPropertiesOnlyTracked(data, dataPath, dataRoot) {
         if (!isObjectType(data)) return true;
+        for (let i = 0; i < requiredCount; ++i) {
+          if (!Object.hasOwn(data, requiredKeys[i]))
+            return false;
+        }
         for (let i = 0; i < propCount; ++i) {
           const key = propKeys[i];
           // Object.hasOwn: avoid picking up inherited members like toString
@@ -722,6 +783,10 @@ export function compileObjectSchema(schemaObj, jsonSchema) {
 
     return function validateObjectPropertiesOnly(data, dataPath, dataRoot) {
       if (!isObjectType(data)) return true;
+      for (let i = 0; i < requiredCount; ++i) {
+        if (!Object.hasOwn(data, requiredKeys[i]))
+          return false;
+      }
       for (let i = 0; i < propCount; ++i) {
         const key = propKeys[i];
         // Object.hasOwn: avoid picking up inherited members like toString
@@ -743,11 +808,39 @@ export function compileObjectSchema(schemaObj, jsonSchema) {
   const validatePrimitives = objectPrimitives || trueThat;
   const validateChildren = objectChildren || trueThat;
 
-  return function validateObjectSchema(data, dataPath, dataRoot) {
+  // Without child validators the data keys are only consumed by the
+  // min/max length checks, which compute them on demand; skip the
+  // per-validation Object.keys allocation.
+  if (objectChildren == null) {
+    return function validateObjectPrimitivesSchema(data, dataPath, dataRoot) {
+      if (isObjectType(data)) {
+        return validatePrimitives(data, dataPath, dataRoot, undefined);
+      }
+      return true;
+    };
+  }
+
+  if (schemaObj.options.skipErrors) {
+    return function validateObjectSchema(data, dataPath, dataRoot) {
+      if (isObjectType(data)) {
+        const dataKeys = Object.keys(data);
+        return validatePrimitives(data, dataPath, dataRoot, dataKeys)
+          && validateChildren(data, dataPath, dataRoot, dataKeys);
+      }
+      return true;
+    };
+  }
+
+  // `required`/`minProperties` and the per-property schemas are independent:
+  // the child walk re-derives everything it needs from the data and cannot
+  // fault on a missing key. Stopping after a missing `required` would report
+  // the absent property and hide every fault in the properties that ARE
+  // present, which is the difference between one issue and a usable list.
+  return function validateObjectSchemaAll(data, dataPath, dataRoot) {
     if (isObjectType(data)) {
       const dataKeys = Object.keys(data);
-      return validatePrimitives(data, dataPath, dataRoot, dataKeys)
-        && validateChildren(data, dataPath, dataRoot, dataKeys);
+      const primitives = validatePrimitives(data, dataPath, dataRoot, dataKeys);
+      return validateChildren(data, dataPath, dataRoot, dataKeys) && primitives;
     }
     return true;
   };

package/src/query.js

@@ -12,6 +12,18 @@
 
 import { JarenValidator } from './index.js';
 
+/**
+ * Project a diagnostic string from whatever the validator threw, without
+ * reading `.message` off a raw value or coercing it.
+ * @param {unknown} e
+ * @returns {string}
+ */
+function failureText(e) {
+  if (e instanceof Error && typeof e.message === 'string')
+    return e.message;
+  return typeof e === 'string' ? e : 'schema compilation failed';
+}
+
 /**
  * Create a `compileTypeTest` hook for `compileJsonQuery` (see
  * `@jarenjs/json/query`), backed by a `JarenValidator`.
@@ -44,8 +56,22 @@ export function createTypeTestCompiler(validator = undefined) {
   const instance = validator == null
     ? new JarenValidator()
     : (typeof validator === 'function' ? validator() : validator);
-  return function compileTypeTest(schemaJson) {
-    const validate = instance.compile(schemaJson);
+  return function compileTypeTest(schemaJson, docPath) {
+    let validate;
+    try {
+      validate = instance.compile(schemaJson);
+    }
+    catch (err) {
+      // The engine's JQ0009 names the operator that owns the schema; this
+      // names the schema literal itself, which is what distinguishes one
+      // failing schema from the others in the same query document.
+      const where = typeof docPath === 'string' && docPath !== '' ? docPath : '';
+      throw new Error(
+        where === ''
+          ? failureText(err)
+          : `schema literal at '${where}': ${failureText(err)}`,
+        { cause: err });
+    }
     // The default validator options are boolean mode (skipErrors on,
     // collectErrors off): the compiled function IS the predicate. An
     // error-collecting instance returns { valid, errors } objects

package/src/schema.js

@@ -5,6 +5,10 @@ import {
   getStringType,
   isObjectClass,
 } from '@jarenjs/core';
+import {
+  NUMERIC_CONSTRAINTS, STRING_CONSTRAINTS,
+  ARRAY_CONSTRAINTS, OBJECT_CONSTRAINTS,
+} from '@jarenjs/core/schema';
 
 import {
   getUniqueArray,
@@ -15,20 +19,23 @@ import {
 } from '@jarenjs/core/number';
 
 import {
-  falseThat,
   trueThat,
   addFunctionToArray,
 } from '@jarenjs/core/function';
 
 import {
+  combineIndependent,
   createIsSchemaTypeHandler,
+  hasSchemaRef,
+  hasSchemaRecursiveRef,
+  hasSchemaDynamicRef,
 } from './tools.js';
 
 import {
   getStringLength,
-  getSegmenter,
 } from '@jarenjs/core/string';
 
+import { compileErrorMessageSpec } from './messages.js';
 import { compileFormatBasic } from './format.js';
 import { compileEnumBasic } from './enum.js';
 import { compileNumberBasic } from './number.js';
@@ -41,9 +48,8 @@ import { compileCombineSchema } from './combine.js';
 import { compileConditionSchema } from './condition.js';
 import { compileDataSchema } from './data.js';
 import { compileQuerySchema } from './query-keyword.js';
-import { compileDollarDataSchema, hasDollarDataReferences } from './dollar-data.js';
+import { compileDollarDataSchema } from './dollar-data.js';
 import { wrapUnevaluated } from './unevaluated.js';
-import { hasSchemaRef, hasSchemaRecursiveRef, hasSchemaDynamicRef } from './tools.js';
 import { createJsonPointer } from './traverse.js';
 
 /**
@@ -168,7 +174,7 @@ function compileDynamicAnchorRef(schemaObj, jsonSchema) {
       let targetObj;
       try {
         targetObj = root.resolveObject(resolvedRef, baseUri, { $ref: resolvedRef });
-      } catch (e) {
+      } catch (_e) {
         return addError(data, dataPath);
       }
       if (targetObj) {
@@ -414,6 +420,20 @@ export function compileSchemaObject(schemaObj, jsonSchema) {
     throw new Error('JSON Schema MUST be a boolean or Object Type');
 
   const keys = Object.keys(jsonSchema);
+
+  // 'errorMessage' is report-time metadata: compile its spec once and
+  // register it on the root - NO validator closure is emitted (the keyword
+  // contributes zero validation-time work), and the key is excluded from
+  // the single-keyword counts so it cannot knock a node off the fast
+  // paths below.
+  let keyCount = keys.length;
+  if (jsonSchema.errorMessage !== undefined) {
+    schemaObj.root.registerErrorMessage(
+      schemaObj.path,
+      compileErrorMessageSpec(jsonSchema.errorMessage, schemaObj.path));
+    keyCount -= 1;
+  }
+
   if (keys.length === 0)
     return trueThat;
 
@@ -423,7 +443,9 @@ export function compileSchemaObject(schemaObj, jsonSchema) {
   // We need to check the actual behavior based on schema context.
   // If schema has ONLY $ref (and meta keywords), use the ref-only path.
   // If schema has $ref with validation siblings, process them together (2019-09+ only).
-  const draftVersion = schemaObj.options.draftVersion || 7;
+  // The resource's own declared draft decides $ref-sibling behavior; see the
+  // note in ValidationObject.compileValidator.
+  const draftVersion = schemaObj.declaredDraft ?? schemaObj.options.draftVersion ?? 7;
   // When compiling the sibling keywords of a $ref schema, the unevaluated*
   // wrapper is applied by ValidationObject.compileValidator around the
   // combined (ref + siblings) validator instead of here, so that the
@@ -431,13 +453,16 @@ export function compileSchemaObject(schemaObj, jsonSchema) {
   let refWithSiblings = false;
   if (hasSchemaRef(jsonSchema) && !hasSchemaRecursiveRef(jsonSchema)) {
     // Check if there are any validation-related sibling keywords
-    // In draft 2019-09+, if there are validation siblings, we process them together
-    const validationKeywords = ['type', 'const', 'enum', 'multipleOf', 'maximum', 'exclusiveMaximum',
-      'minimum', 'exclusiveMinimum', 'maxLength', 'minLength', 'pattern', 'maxItems', 'minItems',
-      'uniqueItems', 'maxContains', 'minContains', 'maxProperties', 'minProperties', 'required',
+    // In draft 2019-09+, if there are validation siblings, we process
+    // them together. Membership-only (order-insensitive): the shared
+    // constraint groups plus the applicators and extras.
+    const validationKeywords = ['type', 'const', 'enum',
+      ...NUMERIC_CONSTRAINTS, ...STRING_CONSTRAINTS,
+      ...ARRAY_CONSTRAINTS, 'maxContains', 'minContains',
+      ...OBJECT_CONSTRAINTS, 'required',
       'dependentRequired', 'properties', 'patternProperties', 'additionalProperties', 'items',
       'prefixItems', 'additionalItems', 'contains', 'allOf', 'anyOf', 'oneOf', 'not', 'if',
-      'then', 'else', 'propertyNames', 'format', 'contentEncoding', 'contentMediaType',
+      'then', 'else', 'propertyNames', 'contentEncoding', 'contentMediaType',
       'unevaluatedProperties', 'unevaluatedItems', '$query'];
     const hasValidationSiblings = keys.some(k => validationKeywords.includes(k));
     // In draft 7 and earlier, $ref always overrides siblings regardless
@@ -449,10 +474,6 @@ export function compileSchemaObject(schemaObj, jsonSchema) {
     refWithSiblings = true;
   }
 
-  // Check if schema has any $data references
-  // If so, we need to use the $data-aware compilation path
-  const hasDollarData = hasDollarDataReferences(jsonSchema);
-
   // When the metaschema's $vocabulary omits the validation vocabulary,
   // keywords like type/enum/minimum/minLength assert nothing.
   const vocabValidation = schemaObj.options.vocabValidation !== false;
@@ -461,7 +482,7 @@ export function compileSchemaObject(schemaObj, jsonSchema) {
   // These inline the validation to reduce function call overhead
 
   // Fast path: type-only schema (most common case: {"type": "string"})
-  if (vocabValidation && keys.length === 1 && jsonSchema.type !== undefined) {
+  if (vocabValidation && keyCount === 1 && jsonSchema.type !== undefined) {
     const type = jsonSchema.type;
     // Only handle single type strings here (not arrays of types)
     if (typeof type === 'string') {
@@ -502,29 +523,45 @@ export function compileSchemaObject(schemaObj, jsonSchema) {
   }
 
   // Fast path: required-only schema (common case: {"required": ["foo", "bar"]})
-  if (vocabValidation && keys.length === 1 && jsonSchema.required !== undefined) {
+  if (vocabValidation && keyCount === 1 && jsonSchema.required !== undefined) {
     const required = jsonSchema.required;
-    if (Array.isArray(required) && required.length > 0) {
+    // Non-string entries (invalid schemas) can never match a data key;
+    // they stay on the generic Object.keys path.
+    if (Array.isArray(required) && required.length > 0
+      && required.every(key => typeof key === 'string')) {
       const addError = schemaObj.createErrorHandler(required, ['required']);
       const rlen = required.length;
 
-      return function validateRequiredOnly(data, dataPath) {
-        // Required only applies to objects, not arrays or primitives
+      if (schemaObj.options.skipErrors) {
+        return function validateRequiredOnly(data, dataPath) {
+          // Required only applies to objects, not arrays or primitives
+          if (typeof data !== 'object' || data === null || Array.isArray(data)) return true;
+          for (let i = 0; i < rlen; i++) {
+            if (!Object.hasOwn(data, required[i])) {
+              return addError(required[i], data, dataPath);
+            }
+          }
+          return true;
+        };
+      }
+
+      // Every absent property is its own fault to report; the fast path must
+      // not be the reason a caller only learns about the first one.
+      return function validateRequiredOnlyAll(data, dataPath) {
         if (typeof data !== 'object' || data === null || Array.isArray(data)) return true;
-        const dataKeys = Object.keys(data);
+        let valid = true;
         for (let i = 0; i < rlen; i++) {
-          if (dataKeys.indexOf(required[i]) === -1) {
-            return addError(required[i], data, dataPath);
-          }
+          if (!Object.hasOwn(data, required[i]))
+            valid = addError(required[i], data, dataPath) && valid;
         }
-        return true;
+        return valid;
       };
     }
   }
 
   // Fast path: minLength-only schema (common case: {"minLength": 2})
   // This avoids the overhead of compileStringBasic for simple cases
-  if (vocabValidation && keys.length === 1 && jsonSchema.minLength !== undefined) {
+  if (vocabValidation && keyCount === 1 && jsonSchema.minLength !== undefined) {
     const min = jsonSchema.minLength;
     if (typeof min === 'number' && min > 0 && Number.isFinite(min)) {
       const addError = schemaObj.createErrorHandler(min, 'minLength');
@@ -548,7 +585,7 @@ export function compileSchemaObject(schemaObj, jsonSchema) {
   }
 
   // Fast path: maxLength-only schema (common case: {"maxLength": 10})
-  if (vocabValidation && keys.length === 1 && jsonSchema.maxLength !== undefined) {
+  if (vocabValidation && keyCount === 1 && jsonSchema.maxLength !== undefined) {
     const max = jsonSchema.maxLength;
     if (typeof max === 'number' && max >= 0 && Number.isFinite(max)) {
       const addError = schemaObj.createErrorHandler(max, 'maxLength');
@@ -613,6 +650,14 @@ export function compileSchemaObject(schemaObj, jsonSchema) {
   if (validators.length === 1)
     return finalize(validators[0]);
 
+  // These are the node's KEYWORD GROUPS (type, string, number, object,
+  // array, combine, ...) and they are independent of one another: each
+  // re-guards the data type it applies to, so continuing past a failed group
+  // is safe. Short-circuiting them is a boolean-mode optimization; when
+  // errors are recorded it lets one group's failure hide every other group's.
+  if (!schemaObj.options.skipErrors)
+    return finalize(combineIndependent(validators));
+
   if (validators.length === 2) {
     const first = validators[0];
     const second = validators[1];

package/src/string.js

@@ -2,7 +2,6 @@
 
 import {
   isStringType,
-  getStringType,
 } from '@jarenjs/core';
 
 import {
@@ -12,7 +11,6 @@ import {
 import {
   createRegExp,
   getStringLength,
-  getSegmenter,
 } from '@jarenjs/core/string';
 
 import {
@@ -70,11 +68,25 @@ function compileStringIntern(schemaObj, jsonSchema) {
   const isMatch = pattern || trueThat;
   const useGrapheme = schemaObj.options.useGrapheme;
 
-  return function validateStringIntern(data, dataPath) {
+  if (schemaObj.options.skipErrors) {
+    return function validateStringIntern(data, dataPath) {
+      const len = getStringLength(data, useGrapheme);
+      return isMinLength(len, dataPath)
+        && isMaxLength(len, dataPath)
+        && isMatch(data, dataPath);
+    };
+  }
+
+  // Length and pattern are independent assertions over the same string:
+  // `len` is computed before any of them and `isMatch` reads the raw data,
+  // so a failed `minLength` says nothing about whether `pattern` holds.
+  // Short-circuiting them is a boolean-mode optimization; when errors are
+  // recorded it would hide half the reasons the value is wrong.
+  return function validateStringInternAll(data, dataPath) {
     const len = getStringLength(data, useGrapheme);
-    return isMinLength(len, dataPath)
-      && isMaxLength(len, dataPath)
-      && isMatch(data, dataPath);
+    let valid = isMinLength(len, dataPath);
+    valid = isMaxLength(len, dataPath) && valid;
+    return isMatch(data, dataPath) && valid;
   };
 }