Validator adds `oneOf` error to `errors` array even when schema is valid

[mdmower-csnw]

When validating a schema that includes oneOf with a ref, an error is pushed to the final validator.errors array even if the oneOf schema passes validation. The overall validation result (true/false) is correct, but when validation fails, one of the errors is not correct.

Steps to reproduce

sample.schema.json

{
  "type": "object",
  "$defs": {
    "level": {
      "enum": ["error", "info"]
    }
  },
  "properties": {
    "some_name": { "type": "string" },
    "some_level": {
      "oneOf": [{ "const": null }, { "$ref": "#/$defs/level" }]
    }
  }
}

sample.json

{
  "some_name": 3,
  "some_level": null
}

main.js

import { validator } from "@exodus/schemasafe";
import { readFileSync } from "fs";

const schema = JSON.parse(readFileSync("sample.schema.json", "utf-8"));
const sample = JSON.parse(readFileSync("sample.json", "utf-8"));
const validate = validator(schema, { includeErrors: true, allErrors: true });
if (!validate(sample)) {
  console.error(validate.errors);
} else {
  console.log("config ok");
}

Output

some_level is reported to have an error even though it doesn't.

[
  {
    keywordLocation: '#/properties/some_name/type',
    instanceLocation: '#/some_name'
  },
  {
    keywordLocation: '#/properties/some_level/oneOf/1/$ref/enum',
    instanceLocation: '#/some_level'
  }
]

Notes

When I inspect the compiled validator, it looks like the error from the failed $ref is pushed onto validate.errors instead of being held in suberr1 to determine later whether it should land in validate.errors depending on the overall oneOf status. See comments in code snippet below:

    if ("some_level" in data && hasOwn(data, "some_level")) {
      let passes0 = 0
      let suberr0 = null
      const sub0 = (() => {
        let errorCount = 0
        if (!(data.some_level === null)) {
          if (suberr0 === null) suberr0 = []
          suberr0.push({ keywordLocation: "#/properties/some_level/oneOf/0/const", instanceLocation: "#/some_level" })
          errorCount++
        }
        return errorCount === 0
      })()
      if (sub0) passes0++
      const sub1 = (() => {
        let errorCount = 0
        const err0 = validate.errors
        const res0 = ref1(data.some_level)
        const suberr1 = ref1.errors
        validate.errors = err0
        if (!res0) {
          if (validate.errors === null) validate.errors = []
/** START: Possible reason for issue */
          validate.errors.push(...suberr1.map(e => errorMerge(e, "#/properties/some_level/oneOf/1/$ref", "#/some_level")))
/** END: Possible reason for issue */
          errorCount++
        }
        return errorCount === 0
      })()
      if (sub1) passes0++
      if (passes0 !== 1) {
        if (validate.errors === null) validate.errors = []
        validate.errors.push({ keywordLocation: "#/properties/some_level/oneOf", instanceLocation: "#/some_level" })
        errorCount++
      }
      if (passes0 === 0) {
        if (suberr0) validate.errors.push(...suberr0)
      }
    }

[somya130104]

Hey! I dug into this and I think this is an error-collection bug in the generated code for oneOf + $ref.

When the $ref branch fails, its errors are immediately pushed into validate.errors:

validate.errors.push(...suberr1.map(...))

But this happens before the oneOf logic decides whether the branch failure matters. So even if another oneOf branch passes (e.g., { const: null }), the $ref errors still leak into the final validate.errors, producing a false-positive error entry.

Suggested fix: in oneOf, errors from each branch should always be collected in a local buffer (suberrX) instead of being pushed to validate.errors. Only after passes !== 1 (i.e., oneOf fails) should the stored suberrX arrays be merged into validate.errors.

I can open a PR that:

updates the compiler output to store $ref branch errors in suberr1

merges them only when oneOf fails

adds a regression test for the exact schema/sample in this issue