@jarenjs/validate 0.9.2 → 0.34.0

package/dist/types/tools.d.ts

@@ -14,7 +14,48 @@ export declare function isOfSchemaType(schema: any, type: any): boolean;
 export declare function hasSchemaRef(schema: any): boolean;
 export declare function hasSchemaRecursiveRef(schema: any): boolean;
 export declare function hasSchemaDynamicRef(schema: any): boolean;
+/**
+ * Whether a sibling keyword of unevaluatedProperties already evaluates every
+ * property of the instance. additionalProperties (boolean or schema) applies
+ * to each property not matched by properties/patternProperties, so once it
+ * has passed no property is left unevaluated.
+ * @param {object} schema - The schema holding the unevaluatedProperties keyword
+ * @returns {boolean} True when the unevaluatedProperties check can never match
+ */
+export declare function hasUnevaluatedPropertiesCoverage(schema: object): boolean;
+/**
+ * Whether a sibling keyword of unevaluatedItems already evaluates every item
+ * of the instance: a uniform items schema (boolean or object) covers all
+ * items beyond any prefixItems, and a tuple-form items with additionalItems
+ * covers the items beyond the tuple.
+ * @param {object} schema - The schema holding the unevaluatedItems keyword
+ * @returns {boolean} True when the unevaluatedItems check can never match
+ */
+export declare function hasUnevaluatedItemsCoverage(schema: object): boolean;
 export declare function createIsSchemaTypeHandler(type: any, isStrict?: boolean): typeof isBooleanType | typeof isRegExpType | undefined;
+/**
+ * The fallback resolver of the data-reference keywords (`data`, `$data`):
+ * a ref that fails the strict compile keeps the lax keyword semantics, so
+ * it resolves as not-found and the keyword asserts nothing.
+ * @returns {any} the JSON Pointer not-found sentinel
+ */
+export declare const resolveNothing: () => any;
+/**
+ * Build the keyword validators the two data-reference keywords share
+ * verbatim. The `data` keyword (json-everything, absolute + relative
+ * pointers via `compileDataRef`) and the Ajv-style `$data` keyword
+ * (relative pointers only) differ ONLY in which pointer compiler
+ * resolves a ref, so each module passes its own `compileRefResolver`
+ * and gets the same fifteen compilers back.
+ *
+ * Every validator follows one lax contract: a data instance outside the
+ * keyword's type, an unresolvable ref, or a resolved constraint of the
+ * wrong type asserts nothing.
+ *
+ * @param {(ref: string) => (dataRoot: any, dataPath: string) => any} compileRefResolver
+ * @returns {Record<string, (schemaObj: object, ref: string) => ((data: any, dataPath: string, dataRoot: any) => boolean) | undefined>}
+ */
+export declare function createDataRefCompilers(compileRefResolver: (ref: string) => (dataRoot: any, dataPath: string) => any): Record<string, (schemaObj: object, ref: string) => ((data: any, dataPath: string, dataRoot: any) => boolean) | undefined>;
 /**
  * Records which properties (string keys) and items (numeric indexes) of a
  * data instance were successfully evaluated during validation, so that
@@ -40,6 +81,23 @@ export declare class EvalLog {
     /** @returns {boolean} True when item `index` of `data` was evaluated at or after `from` (-1 entries cover all items) */
     hasItem(data: any, index: any, from: any): boolean;
 }
+/**
+ * Combine INDEPENDENT keyword validators without short-circuiting.
+ *
+ * `a(...) && b(...)` is the right composition in boolean mode: the answer is
+ * known at the first failure and nothing is gained by continuing. When errors
+ * are recorded it is wrong, because each validator is the only thing that can
+ * report its own fault, so the first failure hides every sibling's. This runs
+ * all of them and ANDs the results — the boolean answer is identical, the
+ * error list is complete.
+ *
+ * Only use it where the validators genuinely are independent. A precondition
+ * (a type guard before a length check) must keep its short-circuit: running
+ * past it is meaningless at best and throws at worst.
+ * @param {Function[]} validators - Independent validators, in report order
+ * @returns {Function} A validator that runs every one of them
+ */
+export declare function combineIndependent(validators: Function[]): Function;
 export declare class ValidationResult {
     match: boolean;
     errors: number;

package/docs/ERROR-MESSAGES.md

@@ -0,0 +1,251 @@
+# Jaren Error Messages & i18n
+
+**Status: normative.** This document specifies the error record shape, the
+message-key space, the `MessageSpec` value type, the `errorMessage`
+keyword, catalogs, and the resolution precedence chain implemented by
+`@jarenjs/validate` (src/messages.js) and mirrored by `@jarenjs/forms`
+(src/messages.js). Locale packs live in `@jarenjs/locales`.
+
+The design premise: **the validator and the forms engine are not the place
+where prose is born.** Every failure is identified by a stable message key
+(`msgid`) plus raw structured `params`; human text is produced only at
+report/render time, over the already-failed set, by a locale catalog. The
+validation hot path (boolean mode, the `skipErrors` no-op handlers, the
+fast-path node compilers) is untouched: switching locale never recompiles
+a validator or a form model's rules.
+
+---
+
+## 1. The error record
+
+Collect-mode validation (`collectErrors: true`) returns
+`{ valid, errors: ValidationError[] }` where every error is:
+
+| member | type | meaning |
+|---|---|---|
+| `keyword` | string | the failed keyword (`type`, `required`, `$query`, ...) |
+| `instancePath` | string | RFC 6901 JSON Pointer to the failing data location |
+| `schemaPath` | string | the schema location (the compiled node's URI path) |
+| `params` | object | keyword-specific raw parameters (section 2) |
+| `msgid` | string | the resolved message key (section 2) |
+| `message` | string | human text — `''` when `messages: false` |
+
+`toJSON()` serializes exactly these six members.
+
+`msgid` resolution: the matched `errorMessage` spec's `$msgid` if any,
+else `params.code` if present (the `$query` runtime codes), else the
+keyword.
+
+With the validator option `messages: false`, conversion skips message
+rendering entirely (`message: ''`; `params` and `msgid` still set) — the
+fast path for applications that render exclusively through
+`localizeErrors` or their own resolver.
+
+### The handler-contract invariant (internal)
+
+Every internal error handler call site obeys: normal handlers
+`addError(data, dataPath, ...extra)`, keyed handlers
+`addKeyedError(dataKey, data, dataPath, ...extra)` — the first meta
+argument is ALWAYS the instance data path, so `instancePath` is a straight
+read. A charCode guard keeps a non-pointer value from ever becoming a
+wrong path (it yields `''`).
+
+### Deliberate `additionalProperties` divergence from ajv
+
+An `additionalProperties: false` failure reports `instancePath` at the
+**offending member** (`/nested/extra`), not at the parent object
+(`/nested`). The object compiler passes the child path
+(`${dataPath}/${dataKey}`) as the error's data path, so the pointer lands
+on the disallowed property itself. This is spec-correct (the failing
+location *is* that property) and friendlier for a UI that highlights the
+field. ajv reports the parent object's path with the property name in
+`params.additionalProperty`; Jaren carries the same `additionalProperty`
+param, so a consumer diffing error sets against ajv should treat the
+`instancePath` difference as intentional, not a bug.
+
+## 2. The message-key registry
+
+One flat namespace:
+
+| Producer | Keys | Params carried |
+|---|---|---|
+| validate keywords | the keyword itself: `type`, `required`, `minimum`, `maximum`, `exclusiveMinimum`, `exclusiveMaximum`, `multipleOf`, `minLength`, `maxLength`, `pattern`, `additionalProperties`, `minProperties`, `maxProperties`, `minItems`, `maxItems`, `uniqueItems`, `contains`, `items`, `allOf`, `anyOf`, `oneOf`, `not`, `format`, `if`, `then`, `else`, `false schema`, `$query` | `type`/`types`; `missingProperty`; `limit` + `comparison`; `multipleOf`; `pattern`; `additionalProperty`; `format` |
+| query runtime via `$query` | the `JQ2xxx` code (`JQ2001`, `JQ2003`, ...) | `{ code, docPath }` |
+| forms field checks | `form/` + the emitted keyword: `form/required`, `form/type`, `form/const`, `form/enum`, `form/minLength`, `form/maxLength`, `form/pattern`, `form/format`, `form/minimum`, `form/maximum`, `form/exclusiveMinimum`, `form/exclusiveMaximum`, `form/multipleOf`, `form/minItems`, `form/maxItems`, `form/uniqueItems`, `form/minProperties`, `form/maxProperties` | per branch: `limit`, `len`, `type`, `format`, `enumValues`, `constValue`, `pattern`, `multipleOf` |
+| forms rules | `x-form/assert` (the default), else the author's `$msgid` | `{ pointer, ...spec.params }` |
+| applications | any `$msgid` they invent — recommend dotted names (`checkout.total-too-low`) | error params + spec params |
+
+Keywords without a built-in English entry (`const`, `enum`,
+`dependentRequired`, `dependencies`, `unevaluatedProperties`, ...) render
+the generic `validation failed for keyword '<keyword>'`; their `msgid` is
+still the keyword, so a catalog (or an application) may cover them.
+
+## 3. MessageSpec
+
+The value type used identically by `errorMessage` (validate),
+`x-form.message` (forms), and anywhere else a message is authored:
+
+```
+MessageSpec = string                      // inline template (author's language)
+            | { "$msgid": string,         // catalog key to resolve at render time
+                "message"?: string,       // inline template fallback on catalog miss
+                "params"?: object }       // merged OVER the error's params
+```
+
+The object form requires `$msgid` and/or `message`; any other member is a
+compile-time error. Spec `params` merge over the error's params **into the
+error record**, so post-hoc localization sees them too.
+
+### Template syntax
+
+Applies to inline templates and to string-valued catalog entries:
+
+- `{name}` substitutes the merged params member `name` — `String(v)` for
+  primitives, `JSON.stringify(v)` otherwise;
+- an unknown name leaves the placeholder literally (debuggability);
+- `{{` escapes a literal `{`.
+
+Templates compile ONCE into a closure (`compileMessageTemplate`) — the
+two-stage house rule applies to messages too. There is **no pointer/data
+interpolation in v1** (`${/foo}` ajv-style is a roadmap follow-up; params
+already carry the relevant values).
+
+## 4. Catalogs
+
+A catalog is a plain flat object:
+`{ [key]: (params, error) => string | templateString }`.
+`compileMessageCatalog(catalogLike)` returns a functions-only frozen copy
+(template strings compiled).
+
+English catalogs are **built in**: validate's `messagesEn`
+(src/messages.js) and forms' `formsMessagesEn` (src/messages.js) — neither
+package gains a dependency. Non-English packs live in `@jarenjs/locales`
+(`nl`, `fr`, `es`, `pt`, `de`, `ja`, `ko`, `zhTW`, `ru`, `tr`, `ar` —
+each also a subpath export, e.g. `@jarenjs/locales/fr`,
+`@jarenjs/locales/zh-tw`) and must have key parity with the built-in
+English (enforced by repo tests).
+
+### Pack authoring (globalization mechanics)
+
+Catalog entries are functions precisely so packs can use the platform:
+
+- `Intl.PluralRules` for plural category selection ("1 teken" /
+  "2 tekens" — see the `nl` pack's `minLength`),
+- `Intl.NumberFormat` for `{limit}`-style numbers,
+- `Intl.ListFormat` for enum lists.
+
+Hold these as module-level singletons (allocation discipline). **Bidi:**
+packs targeting RTL scripts should isolate interpolated user values with
+FSI/PDI (U+2068/U+2069) — the pack author's call, not core's. A pack
+depends on nothing outside the Jaren suite, and inside it on nothing but
+`@jarenjs/core` — never on `@jarenjs/validate` or `@jarenjs/forms`, so
+either consumer can serve any pack.
+
+## 5. Resolution precedence
+
+Implemented in validate's conversion (`convertInternalErrors`); forms
+mirrors the tail of the chain:
+
+1. the nearest `errorMessage` spec for the error (section 6 matching);
+2. if the spec has `$msgid`: active catalog → built-in English catalog →
+   the spec's inline `message` template;
+3. if the spec is inline (string / `message`-only): render it;
+4. no spec: active catalog[`msgid`] → built-in English[`msgid`] →
+   catalog[`keyword`] → English[`keyword`] (so uncovered `JQ*` codes still
+   say something) → `validation failed for keyword '<keyword>'`.
+
+At conversion time the "active catalog" is the built-in English; other
+locales enter through `localizeErrors` / `renderErrorMessage` (section 7)
+or, in forms, through the `catalog` parameters.
+
+## 6. The `errorMessage` keyword
+
+**Overrides text, never structure.** Deliberate divergences from
+ajv-errors:
+
+- errors are never removed, merged, or aggregated;
+- no synthetic `keyword: "errorMessage"` error is created;
+- originals are never moved into `params.errors`;
+- no `${/pointer}` data interpolation (v1);
+- no `properties`/`items` map forms — the subtree prefix rule covers what
+  those express (roadmap follow-up if demand appears).
+
+An `errorMessage` spec only changes what `message` (and `msgid`) say on
+the errors it matches.
+
+### Grammar
+
+Validated at schema compile time; malformed specs throw with the schema
+path.
+
+```jsonc
+"errorMessage": MessageSpec                        // string form: whole subtree
+"errorMessage": {                                  // map form
+  "minLength": MessageSpec,                        // per failing keyword, this node
+  "required": MessageSpec                          // all required failures here
+           | { "vatId": MessageSpec, ... },        // or per missing property
+  "$query": MessageSpec                            // EBV-false and any runtime code
+          | { "default": MessageSpec,              // EBV-false
+              "JQ2001": MessageSpec, ... },        // per runtime code
+  "_": MessageSpec                                 // node-level catch-all
+}
+```
+
+### Matching
+
+The compiler registers each spec by schema location on the compilation
+root — **no validator closure is emitted**; the keyword contributes zero
+validation-time work and never knocks a node off the fast paths. At
+report time:
+
+- candidate nodes are the registered locations that equal the error's
+  `schemaPath` or are a segment-aware prefix of it (`/foo` never matches
+  `/foobar`); the longest prefix is tried first;
+- **at the error's own node**: keyword-map entry (with `required`
+  per-property matching on `params.missingProperty`, `$query` per-code on
+  `params.code`, `default` on its absence) > `_` > string form;
+- **at an ancestor**: only the string form applies (it covers the
+  subtree — this is what lets one string on a `oneOf` replace the branch
+  noise);
+- no match at the nearest node falls through to farther ancestors.
+
+## 7. Post-hoc localization
+
+```js
+import { JarenValidator, compileMessageCatalog, localizeErrors } from '@jarenjs/validate';
+import { nl } from '@jarenjs/locales';
+
+const catalog = compileMessageCatalog(nl);
+const result = validate(data);          // English messages
+localizeErrors(result.errors, catalog); // Dutch messages, same array
+```
+
+`localizeErrors(errors, catalog)` re-renders `message` on each error from
+`msgid` + `params` through the given compiled catalog with built-in
+English fallback. Contract details:
+
+- **inline schema-authored text without `$msgid` is single-language by
+  definition and is NOT re-rendered** — that is why `$msgid` exists;
+- an error whose `msgid` resolves in no catalog keeps its current message
+  (e.g. a custom `$msgid`'s inline fallback text);
+- `renderErrorMessage(error, catalog?)` is the single-error form of the
+  same chain (section 5 step 4).
+
+Forms renders eagerly (failure-only, cheap, keeps UI consumers simple)
+but through the same catalog contract: `validateField` /
+`validateAllFields` / `evaluateFormRules` accept an optional compiled
+catalog, default English, and every `FieldError` carries
+`{ keyword, params, msgid, message }` so consumers can re-render.
+
+## 8. Why not MessageFormat 2
+
+`Intl.MessageFormat` (MessageFormat 2) is TC39 Stage 2 and stalled,
+shipping in no runtime; adopting it would mean a runtime dependency or a
+homegrown MF2 engine for pluralization the platform already provides
+through `Intl.PluralRules`. Catalogs-as-functions cover the same ground
+with no runtime dependency beyond the platform, and with full generality.
+
+**Revisit trigger:** Intl.MessageFormat reaching TC39 Stage 3 or shipping
+in a major runtime. At that point, MF2 syntax could become a supported
+catalog *entry format* (compiled by `compileMessageCatalog`) without
+changing the catalog contract.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jarenjs/validate",
   "private": false,
-  "version": "0.9.2",
+  "version": "0.34.0",
   "type": "module",
   "main": "./src/index.js",
   "types": "./dist/types/index.d.ts",
@@ -15,11 +15,16 @@
       "types": "./dist/types/query.d.ts",
       "default": "./src/query.js"
     },
+    "./normalize": {
+      "types": "./dist/types/normalize.d.ts",
+      "default": "./src/normalize.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "dist/types/",
     "src/",
+    "docs/",
     "ARCHITECTURE.md"
   ],
   "description": "Jaren is a JavaScript JSON Schema Validator",
@@ -31,7 +36,7 @@
   },
   "license": "MIT",
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "publishConfig": {
     "access": "public",
@@ -50,7 +55,7 @@
     "prepack": "npm run build:types"
   },
   "dependencies": {
-    "@jarenjs/core": "^0.9.2",
-    "@jarenjs/json": "^0.9.2"
+    "@jarenjs/core": "^0.34.0",
+    "@jarenjs/json": "^0.34.0"
   }
 }

package/src/array.js

@@ -225,22 +225,29 @@ function compileItemValidator(schemaObj, itemSchema, key, index) {
             if (targetObj && targetObj.validate) {
               return targetObj.validate;
             }
-          } catch (e) {
+          } catch (_e) {
             // Fall through to default handling
           }
         }
       }
     }
 
+    // The two fast paths below return bare predicates with no error handler,
+    // so a failing item reports nothing of its own and the caller can only
+    // aggregate one error at the array path. When errors are recorded, fall
+    // through to full compilation so each failing item yields its own error
+    // at its own instancePath, matching the multi-keyword path.
+    const stopAtFirst = schemaObj.root.options.skipErrors;
+
     // Fast path: type-only schema (most common case) - check property directly first
-    if (itemSchema.type !== undefined && Object.keys(itemSchema).length === 1) {
+    if (stopAtFirst && itemSchema.type !== undefined && Object.keys(itemSchema).length === 1) {
       return compileTypeOnlyValidator(itemSchema.type);
     }
 
     // Fast path: required-only schema - check property directly first
-    if (itemSchema.required !== undefined && Object.keys(itemSchema).length === 1) {
+    if (stopAtFirst && itemSchema.required !== undefined && Object.keys(itemSchema).length === 1) {
       const required = itemSchema.required;
-      return function validateRequiredOnly(data, dataPath, dataRoot) {
+      return function validateRequiredOnly(data, _dataPath, _dataRoot) {
         // Required properties only apply to objects, not arrays or other types
         if (typeof data !== 'object' || data === null || Array.isArray(data)) return true;
         for (let i = 0; i < required.length; i++) {
@@ -337,11 +344,22 @@ export function compileArrayPrimitives(schemaObj, jsonSchema) {
   const isMinItems = minItems || trueThat;
   const isMaxItems = maxItems || trueThat;
 
-  return function validateArrayPrimitives(data, dataPath) {
+  if (schemaObj.options.skipErrors) {
+    return function validateArrayPrimitives(data, dataPath) {
+      const len = data.length;
+      return isMinItems(len, dataPath)
+        && isMaxItems(len, dataPath)
+        && uniqueItems(data, dataPath);
+    };
+  }
+
+  // Length and uniqueness are independent: a short array can also contain
+  // duplicates, and a caller fixing one wants to hear about the other.
+  return function validateArrayPrimitivesAll(data, dataPath) {
     const len = data.length;
-    return isMinItems(len, dataPath)
-      && isMaxItems(len, dataPath)
-      && uniqueItems(data, dataPath);
+    let valid = isMinItems(len, dataPath);
+    valid = isMaxItems(len, dataPath) && valid;
+    return uniqueItems(data, dataPath) && valid;
   };
 }
 
@@ -392,7 +410,7 @@ function compileArrayChildren(schemaObj, jsonSchema) {
 
       // Wrap single-item validator with index loop
       const itemValidator = validateItem;
-      validateItem = function validateSingleItemSchema(data, dataPath, dataRoot, i) {
+      validateItem = function validateSingleItemSchema(data, dataPath, dataRoot, _i) {
         return itemValidator(data, dataPath, dataRoot);
       };
     } else if (items === true) {
@@ -421,7 +439,7 @@ function compileArrayChildren(schemaObj, jsonSchema) {
       // items: true evaluates every item, which matters when annotations
       // are tracked for unevaluatedItems.
       if (track) {
-        return function validateArrayItemsTrue(data, dataPath, dataRoot) {
+        return function validateArrayItemsTrue(data, _dataPath, _dataRoot) {
           root.evalLog.add(data, -1);
           return true;
         };
@@ -459,7 +477,9 @@ function compileArrayChildren(schemaObj, jsonSchema) {
     return function validateArrayContainsOnly(data, dataPath) {
       const len = resolveLength(data.length);
       const arr = data;
-
+      // Each element is a CANDIDATE probe: the array only has to contain a
+      // match, so an element that is not one has done nothing wrong.
+      const errors = root.errorMark();
       let contains = 0;
       for (let i = 0; i < len; ++i) {
         if (validator(arr[i], dataPath) === true) {
@@ -467,6 +487,7 @@ function compileArrayChildren(schemaObj, jsonSchema) {
           if (trackContains) root.evalLog.add(data, i);
         }
       }
+      root.rollbackErrors(errors);
       return validateMinMax(contains, dataPath);
     };
   }
@@ -475,6 +496,7 @@ function compileArrayChildren(schemaObj, jsonSchema) {
   const itemValidator = validateItem;
   const containsValidator = validateContains;
 
+  const stopAtFirstContains = schemaObj.options.skipErrors;
   return function validateArrayChildren(data, dataPath, dataRoot) {
     const len = resolveLength(data.length);
     const arr = data;
@@ -491,13 +513,18 @@ function compileArrayChildren(schemaObj, jsonSchema) {
       else if (track && i < evalLimit) {
         root.evalLog.add(data, i);
       }
+      // A contains candidate is a probe: not matching is not a fault.
+      const containsMark = root.errorMark();
       if (containsValidator(obj, dataPath, dataRoot) === true) {
         contains++;
         if (trackContains) root.evalLog.add(data, i);
       }
+      root.rollbackErrors(containsMark);
     }
-    return invalid === 0
-      && validateMinMax(contains, dataPath);
+    // Failing items and the contains count are independent tallies.
+    const itemsOk = invalid === 0;
+    if (stopAtFirstContains && !itemsOk) return false;
+    return validateMinMax(contains, dataPath) && itemsOk;
   };
 }
 
@@ -538,12 +565,21 @@ export function compileArraySchema(schemaObj, jsonSchema) {
   if (parts.length === 2) {
     const first = parts[0];
     const second = parts[1];
-    return function validateArraySchemaDouble(data, dataPath, dataRoot) {
-      if (isArrayClass(data)) {
-        return first(data, dataPath, dataRoot)
-          && second(data, dataPath, dataRoot);
-      }
-      return true;
+    if (schemaObj.options.skipErrors) {
+      return function validateArraySchemaDouble(data, dataPath, dataRoot) {
+        if (isArrayClass(data)) {
+          return first(data, dataPath, dataRoot)
+            && second(data, dataPath, dataRoot);
+        }
+        return true;
+      };
+    }
+    // The two parts are independent array keyword groups (length/uniqueness
+    // versus the item walk); the array-class guard stays a precondition.
+    return function validateArraySchemaDoubleAll(data, dataPath, dataRoot) {
+      if (!isArrayClass(data)) return true;
+      const firstOk = first(data, dataPath, dataRoot);
+      return second(data, dataPath, dataRoot) && firstOk;
     };
   }
 
@@ -551,13 +587,22 @@ export function compileArraySchema(schemaObj, jsonSchema) {
   const hasBooleanItems = compiledItemsBoolean || trueThat;
   const hasBooleanContains = compiledContainsBoolean || trueThat;
   const validateItems = compiledArrayChildren || trueThat;
+  const stopAtFirstSchema = schemaObj.options.skipErrors;
 
   return function validateArraySchema(data, dataPath, dataRoot) {
     if (isArrayClass(data)) {
-      return validatePrimitives(data, dataPath)
-        && hasBooleanItems(data, dataPath, dataRoot)
-        && hasBooleanContains(data, dataPath, dataRoot)
-        && validateItems(data, dataPath, dataRoot);
+      if (stopAtFirstSchema) {
+        return validatePrimitives(data, dataPath)
+          && hasBooleanItems(data, dataPath, dataRoot)
+          && hasBooleanContains(data, dataPath, dataRoot)
+          && validateItems(data, dataPath, dataRoot);
+      }
+      // Length/uniqueness, the boolean items/contains forms and the item
+      // walk are independent; a length failure must not hide item faults.
+      let valid = validatePrimitives(data, dataPath);
+      valid = hasBooleanItems(data, dataPath, dataRoot) && valid;
+      valid = hasBooleanContains(data, dataPath, dataRoot) && valid;
+      return validateItems(data, dataPath, dataRoot) && valid;
     }
     return true;
   };

package/src/bigint.js

@@ -86,12 +86,23 @@ export function compileBigIntBasic(schemaObj, jsonSchema) {
   const isMin = minimum || trueThat;
   const isMul = multipleOf || trueThat;
 
-  return function validateBigIntSchema(data, dataPath) {
-    if (isBigIntType(data)) {
-      return isMax(data, dataPath)
-        && isMin(data, dataPath)
-        && isMul(data, dataPath);
-    }
-    return true;
+  if (schemaObj.options.skipErrors) {
+    return function validateBigIntSchema(data, dataPath) {
+      if (isBigIntType(data)) {
+        return isMax(data, dataPath)
+          && isMin(data, dataPath)
+          && isMul(data, dataPath);
+      }
+      return true;
+    };
+  }
+
+  // The type guard stays a precondition; the three assertions inside it are
+  // independent and each must get to report its own fault.
+  return function validateBigIntSchemaAll(data, dataPath) {
+    if (!isBigIntType(data)) return true;
+    let valid = isMax(data, dataPath);
+    valid = isMin(data, dataPath) && valid;
+    return isMul(data, dataPath) && valid;
   };
 }