Valibot resolver doesn't collect rawCheck issues when base schema fails

[stefan-girlich]

Hi everyone,

I ran into an issue where validation errors from v.rawCheck weren't showing up in my form
until all other fields were valid first. Once they became valid once, errors would show
correctly even after making those fields invalid again.

Environment

• react-hook-form 7.56.3
• @hookform/resolvers 5.2.2

Root issue

When using v.rawCheck for custom validation logic, issues I add via addIssue() don't appear
in the form errors if the base schema validation fails (dataset.typed === false).

The resolver uses safeParseAsync which doesn't seem to include rawCheck issues when the
schema isn't fully "typed":

const result = await safeParseAsync(schema, values, schemaOpts);

if (result.issues) {  // ⚠️ rawCheck issues missing when dataset.typed is false
// process errors...
}

Workaround

Switching to a custom resolver with parse/parseAsync (which throws a ValiError) that collects all issues from the
pipeline, including rawCheck issues regardless of dataset.typed:

try {
const parsed = await parseAsync(schema, values, schemaOpts);
return { values: parsed, errors: {} };
} catch (error) {
if (isValiError(error)) {
  // error.issues contains ALL issues, including rawCheck ✅
  return { values: {}, errors: toNestErrors(parseErrors(error.issues, ...), options) };
}
throw error;
}

I lack the experience with react-hook-form resolvers and valibot to tell what the expected behavior should be.
Happy to submit a PR if this should be fixed in the resolver.

Full valibotResolver.ts code with workaround

import { toNestErrors } from '@hookform/resolvers'
import { appendErrors, FieldError, FieldErrors, FieldValues, Resolver } from 'react-hook-form'
import * as v from 'valibot'

type ResolverOptions = {
  mode?: 'sync' | 'async'
  raw?: boolean
}

const parseErrors = (
  issues: v.BaseIssue<unknown>[],
  validateAllFieldCriteria: boolean
): FieldErrors => {
  const errors: Record<string, FieldError> = {}

  for (const issue of issues) {
    if (!issue.path) {
      continue // eslint-disable-line no-continue
    }
    const _path = issue.path.map(({ key }) => key).join('.')

    if (!errors[_path]) {
      errors[_path] = { message: issue.message, type: issue.type }
    }

    if (validateAllFieldCriteria) {
      const { types } = errors[_path]
      const messages = types && types[issue.type]

      errors[_path] = appendErrors(
        _path,
        validateAllFieldCriteria,
        errors,
        issue.type,
        messages ? ([] as string[]).concat(messages as string[], issue.message) : issue.message
      ) as FieldError
    }
  }

  return errors
}

/**
 * Custom valibot resolver for react-hook-form.
 *
 * Uses `parse`/`parseAsync` instead of `safeParse`/`safeParseAsync` (used by @hookform/resolvers) to ensures that 
 * issues from `rawCheck` are collected even when the base schema fails validation.
 * The official resolver's `safeParse` approach doesn't include `rawCheck` issues when `dataset.typed` is false.
 */
export const valibotResolver =
  <TSchema extends v.GenericSchema<FieldValues>>(
    schema: TSchema,
    schemaOptions?: v.Config<v.InferIssue<TSchema>>,
    resolverOptions: ResolverOptions = {}
  ): Resolver<v.InferInput<TSchema>> =>
  async (values, _, options) => {
    try {
      const schemaOpts = {
        abortEarly: false,
        abortPipeEarly: false,
        ...schemaOptions,
      }

      const parsed =
        resolverOptions.mode === 'sync'
          ? v.parse(schema, values, schemaOpts)
          : await v.parseAsync(schema, values, schemaOpts)

      return {
        values: resolverOptions.raw ? values : parsed,
        errors: {} as FieldErrors,
      }
    } catch (error) {
      if (v.isValiError(error)) {
        return {
          values: {},
          errors: toNestErrors(
            parseErrors(
              error.issues,
              !options.shouldUseNativeValidation && options.criteriaMode === 'all'
            ),
            options
          ),
        }
      }

      throw error
    }
  }