React Hook Form is one of the most used form libraries in React, and its latest release is a big quality update. Version 7.92.0, published on 11 November 2026, ships 32 bug fixes, a performance improvement and a pile of new regression tests. There are no new APIs, but several fixes change behaviour you might have worked around, especially around reset(), field arrays, async validation and dirty state. This guide groups the fixes by area, shows the code patterns they affect, and gives you a safe upgrade checklist.

Upgrade

npm install [email protected]
# or
pnpm add [email protected]

All details below come from the official v7.92.0 release notes. Note that a separate v8 line is in beta (v8.0.0-beta.5 was published in October), so 7.92 is the version to use in production today.

Performance: less cloning in useFormState and Controller

The one performance item (#13945) stops useFormState and Controller from cloning form state unnecessarily during mount and unmount. Large forms with many Controller-wrapped components (date pickers, selects, rich inputs) should benefit most, since each of them used to copy state as it mounted.

You don’t need to change any code to get this. A typical setup like this simply does less work:

import { useForm, Controller } from 'react-hook-form';
import Select from 'react-select';

export function ProfileForm() {
  const { control, handleSubmit } = useForm({
    defaultValues: { country: null, skills: [] },
  });

  return (
    <form onSubmit={handleSubmit(console.log)}>
      <Controller
        name="country"
        control={control}
        render={({ field }) => <Select {...field} options={countries} />}
      />
      <button type="submit">Save</button>
    </form>
  );
}

reset() fixes

Several fixes target reset(), one of the most common sources of confusing form bugs:

  • handleSubmit no longer updates form state incorrectly when reset() is called during an asynchronous submit callback.
  • reset now updates isValid after cancelling pending validation.
  • Repeated reset() calls and error focusing work with keepFieldsRef and memoized inputs.
  • In React Native, useWatch no longer misses reset() updates on mount.

The async-submit fix is worth knowing. This pattern, resetting after a successful save, should now leave form state consistent:

const {
  register,
  handleSubmit,
  reset,
  formState: { isSubmitSuccessful, isDirty },
} = useForm({ defaultValues: { title: '' } });

const onSubmit = async (data) => {
  await api.savePost(data);
  reset(data); // new baseline: the saved values are now "clean"
};

If you previously added a setTimeout or a useEffect around reset() to avoid stale state, try removing it after upgrading and re-test.

Field array fixes

useFieldArray gets several fixes:

  • It no longer applies reValidateMode: 'onSubmit' before the form is submitted.
  • It no longer keeps validation rules after you remove the rules prop.
  • Field array notifications no longer use stale values.
  • Stale schema resolver errors no longer linger after field array operations.
  • trigger no longer loses nested field array root errors.

That last one matters for rules on the array itself, such as “at least one item”:

const { control, register, trigger } = useForm({
  defaultValues: { items: [] },
});

const { fields, append, remove } = useFieldArray({
  control,
  name: 'items',
  rules: { minLength: { value: 1, message: 'Add at least one item' } },
});

// Root-level error for the array, now kept correctly by trigger()
// errors.items?.root?.message

Validation fixes

Async validation had some sharp edges that are now smoothed out:

  • Stale asynchronous form-level validation results are fixed.
  • Form-level validation errors no longer appear before submission during isValid checks.
  • Stale field errors are cleared when form-level validation returns a message.
  • trigger now marks nested fields as touched when shouldTouch targets a parent.

If you use a schema resolver (Zod, Yup, Valibot) with mode: 'onChange' and a field triggers an async check, you should see fewer cases where an old error briefly flashes after a newer, valid result.

import { zodResolver } from '@hookform/resolvers/zod';
import { z } from 'zod';

const schema = z.object({
  username: z.string().min(3, 'At least 3 characters'),
});

const form = useForm({
  resolver: zodResolver(schema),
  mode: 'onChange',
});

Dirty state and setValue / setValues

Dirty tracking drives “unsaved changes” warnings and Save buttons, so these fixes are practical:

  • setValues now updates dirty state for unregistered fields.
  • setValues no longer ignores options when values stay the same.
  • useController dirty tracking works with a controller-level defaultValue.
  • setValue now selects checkbox options whose value is an empty string.
  • Multi-select changes no longer include disabled options.
  • register no longer overwrites untouched range and color input defaults.
// Mark a field dirty and validate it in one call
setValue('email', '[email protected]', {
  shouldDirty: true,
  shouldValidate: true,
});

Registration and unregister

  • unregister no longer keeps descendant registrations when you remove a parent.
  • useController no longer reads stale shouldUnregister options.
  • Focusing disabled radio and checkbox inputs is fixed, so error focus won’t land on a field the user can’t use.
  • Default values now apply correctly to selects with disabled <optgroup> elements.

Submission and the Form component

  • handleSubmit supports nullish and primitive transformed values when fields are disabled.
  • Rejected submission callbacks with falsy rejection reasons are handled.
  • <Form /> now respects encType when building request bodies.

The <Form /> fix matters for file uploads:

import { Form, useForm } from 'react-hook-form';

function UploadForm() {
  const { control, register } = useForm();
  return (
    <Form
      control={control}
      action="/api/upload"
      method="post"
      encType="multipart/form-data"
    >
      <input type="file" {...register('file')} />
      <button>Upload</button>
    </Form>
  );
}

TypeScript fixes

Two type fixes are included: a TypeScript type regression and nested array paths not preserving undefined. If you added as casts to silence errors after an earlier upgrade, check whether you can remove them.

A safe upgrade checklist

  1. Upgrade in a branch and run your form tests; the project itself added broad regression coverage for reset, useController, useFieldArray, validation and submission.
  2. Search for workarounds around reset(), trigger() and setValues(), such as setTimeout calls or manual clearErrors(), and re-test without them.
  3. Check “unsaved changes” logic, because dirty state is now more accurate and may flip in places it didn’t before.
  4. Test disabled fields in radio groups, checkboxes and multi-selects.
  5. Test file uploads that use <Form encType=...>.
  6. Keep an eye on the v8 beta, but stay on 7.92 for production.

Takeaway

React Hook Form 7.92.0 is a “boring but important” release: 32 fixes that make reset(), field arrays, async validation and dirty tracking behave the way most people already assumed they did, plus less state cloning in Controller-heavy forms. Upgrade, remove old workarounds carefully, and run your form tests. The complete list of changes is in the release notes.