react-hook-form 8.0.0-beta.2 → 8.0.0-beta.4

package/dist/react-server.esm.mjs

@@ -31,38 +31,37 @@ const INPUT_VALIDATION_RULES = {
     required: 'required',
     validate: 'validate',
 };
+const REGISTER_VALIDATION_RULES = [
+    INPUT_VALIDATION_RULES.required,
+    INPUT_VALIDATION_RULES.min,
+    INPUT_VALIDATION_RULES.max,
+    INPUT_VALIDATION_RULES.minLength,
+    INPUT_VALIDATION_RULES.maxLength,
+    INPUT_VALIDATION_RULES.pattern,
+    INPUT_VALIDATION_RULES.validate,
+];
 const FORM_ERROR_TYPE = 'form';
 const ROOT_ERROR_TYPE = 'root';
-
-var isDateObject = (value) => value instanceof Date;
-
-var isNullOrUndefined = (value) => value == null;
-
-const isObjectType = (value) => typeof value === 'object';
-var isObject = (value) => !isNullOrUndefined(value) &&
-    !Array.isArray(value) &&
-    isObjectType(value) &&
-    !isDateObject(value);
-
-var isPlainObject = (tempObject) => {
-    const prototypeCopy = tempObject.constructor && tempObject.constructor.prototype;
-    return (isObject(prototypeCopy) && prototypeCopy.hasOwnProperty('isPrototypeOf'));
-};
+const PROTOTYPE_KEYWORDS = ['__proto__', 'constructor', 'prototype'];
 
 var isWeb = typeof window !== 'undefined' &&
     typeof window.HTMLElement !== 'undefined' &&
     typeof document !== 'undefined';
 
 function cloneObject(data) {
+    if (data === null || typeof data !== 'object') {
+        return data;
+    }
     if (data instanceof Date) {
         return new Date(data);
     }
+    const isBlobInstance = typeof Blob !== 'undefined' && data instanceof Blob;
     const isFileListInstance = typeof FileList !== 'undefined' && data instanceof FileList;
-    if (isWeb && (data instanceof Blob || isFileListInstance)) {
+    if (isWeb && (isBlobInstance || isFileListInstance)) {
         return data;
     }
     const isArray = Array.isArray(data);
-    if (!isArray && !(isObject(data) && isPlainObject(data))) {
+    if (!isArray && data.constructor !== Object) {
         return data;
     }
     const copy = isArray ? [] : Object.create(Object.getPrototypeOf(data));
@@ -106,9 +105,25 @@ var createSubject = () => {
     };
 };
 
+var isDateObject = (value) => value instanceof Date;
+
+var isNullOrUndefined = (value) => value == null;
+
+const isObjectType = (value) => typeof value === 'object';
+var isObject = (value) => !isNullOrUndefined(value) &&
+    !Array.isArray(value) &&
+    isObjectType(value) &&
+    !isDateObject(value);
+
+var isPlainObject = (tempObject) => {
+    const prototypeCopy = tempObject.constructor && tempObject.constructor.prototype;
+    return (isObject(prototypeCopy) && prototypeCopy.hasOwnProperty('isPrototypeOf'));
+};
+
 var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
 
-function deepEqual(object1, object2, visited = new WeakSet()) {
+const isEmptyObjectWithCustomPrototype = (object, keys) => keys.length === 0 && !Array.isArray(object) && !isPlainObject(object);
+function deepEqual(object1, object2, visited = new WeakMap()) {
     if (object1 === object2) {
         return true;
     }
@@ -123,11 +138,25 @@ function deepEqual(object1, object2, visited = new WeakSet()) {
     if (keys1.length !== keys2.length) {
         return false;
     }
-    if (visited.has(object1) || visited.has(object2)) {
+    if (isEmptyObjectWithCustomPrototype(object1, keys1) ||
+        isEmptyObjectWithCustomPrototype(object2, keys2)) {
+        return Object.is(object1, object2);
+    }
+    if (!keys1.length && Array.isArray(object1) !== Array.isArray(object2)) {
+        return false;
+    }
+    const visitedPairs = visited.get(object1);
+    if (visitedPairs && visitedPairs.has(object2)) {
         return true;
     }
-    visited.add(object1);
-    visited.add(object2);
+    if (visitedPairs) {
+        visitedPairs.add(object2);
+    }
+    else {
+        const ws = new WeakSet();
+        ws.add(object2);
+        visited.set(object1, ws);
+    }
     for (const key of keys1) {
         const val1 = object1[key];
         if (!(key in object2)) {
@@ -148,16 +177,15 @@ function deepEqual(object1, object2, visited = new WeakSet()) {
 }
 
 function extractFormValues(fieldsState, formValues) {
-    const values = {};
+    const values = (Array.isArray(fieldsState) ? [] : {});
     for (const key in fieldsState) {
         if (fieldsState.hasOwnProperty(key)) {
             const fieldState = fieldsState[key];
             const fieldValue = formValues[key];
-            if (fieldState && isObject(fieldState) && fieldValue) {
-                const nestedFieldsState = extractFormValues(fieldState, fieldValue);
-                if (isObject(nestedFieldsState)) {
-                    values[key] = nestedFieldsState;
-                }
+            if (fieldState &&
+                (isObject(fieldState) || Array.isArray(fieldState)) &&
+                fieldValue) {
+                values[key] = extractFormValues(fieldState, fieldValue);
             }
             else if (fieldsState[key]) {
                 values[key] = fieldValue;
@@ -167,17 +195,22 @@ function extractFormValues(fieldsState, formValues) {
     return values;
 }
 
-var isKey = (value) => /^\w*$/.test(value);
+const IS_KEY_RE = /^\w*$/;
+var isKey = (value) => IS_KEY_RE.test(value);
 
 var isUndefined = (val) => val === undefined;
 
-var stringToPath = (input) => compact(input.replace(/["|']|\]/g, '').split(/\.|\[/));
+const FIELD_PATH_RE = /[.[\]'"]/;
+var stringToPath = (input) => input.split(FIELD_PATH_RE).filter(Boolean);
 
 var get = (object, path, defaultValue) => {
     if (!path || !isObject(object)) {
         return defaultValue;
     }
     const paths = isKey(path) ? [path] : stringToPath(path);
+    if (paths.some((key) => PROTOTYPE_KEYWORDS.includes(key))) {
+        return defaultValue;
+    }
     const result = paths.reduce((result, key) => {
         return isNullOrUndefined(result) ? undefined : result[key];
     }, object);
@@ -188,6 +221,24 @@ var get = (object, path, defaultValue) => {
         : result;
 };
 
+const hasOwn = (value, key) => value !== null &&
+    isObjectType(value) &&
+    Object.prototype.hasOwnProperty.call(value, key);
+var has = (object, path) => {
+    if (!path) {
+        return false;
+    }
+    let result = object;
+    for (const key of isKey(path) ? [path] : stringToPath(path)) {
+        if (!hasOwn(result, key)) {
+            // `get` also resolves a path held as a single literal key, eg `{ 'a.b': 1 }`
+            return hasOwn(object, path);
+        }
+        result = result[key];
+    }
+    return true;
+};
+
 var isBoolean = (value) => typeof value === 'boolean';
 
 var isCheckBoxInput = (element) => element.type === 'checkbox';
@@ -234,7 +285,7 @@ var set = (object, path, value) => {
                         ? []
                         : {};
         }
-        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+        if (PROTOTYPE_KEYWORDS.includes(key)) {
             return;
         }
         object[key] = newValue;
@@ -243,7 +294,7 @@ var set = (object, path, value) => {
 };
 
 function baseGet(object, updatePath) {
-    const length = updatePath.slice(0, -1).length;
+    const length = updatePath.length - 1;
     let index = 0;
     while (index < length) {
         if (isNullOrUndefined(object)) {
@@ -273,6 +324,9 @@ function unset(object, path) {
         : isKey(path)
             ? [path]
             : stringToPath(path);
+    if (paths.some((segment) => PROTOTYPE_KEYWORDS.includes(String(segment)))) {
+        return object;
+    }
     const childObject = paths.length === 1 ? object : baseGet(object, paths);
     const index = paths.length - 1;
     const key = paths[index];
@@ -287,6 +341,24 @@ function unset(object, path) {
     return object;
 }
 
+function isDirtyContainer(value) {
+    return Array.isArray(value) || isObject(value);
+}
+function collectDirtyFieldNames(dirtyTree, cachedDirtyFields, prefix = '', names = []) {
+    for (const key in dirtyTree) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        const value = dirtyTree[key];
+        if (isDirtyContainer(value) &&
+            isDirtyContainer(get(cachedDirtyFields, path))) {
+            collectDirtyFieldNames(value, cachedDirtyFields, path, names);
+        }
+        else {
+            names.push(path);
+        }
+    }
+    return names;
+}
+
 var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) => {
     if (isString(names)) {
         isGlobal && _names.watch.add(names);
@@ -294,7 +366,7 @@ var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) =>
     }
     if (Array.isArray(names)) {
         return names.map((fieldName) => (isGlobal && _names.watch.add(fieldName),
-            get(formValues, fieldName)));
+            get(formValues, fieldName, get(defaultValue, fieldName))));
     }
     isGlobal && (_names.watchAll = true);
     return formValues;
@@ -312,12 +384,33 @@ var objectHasFunction = (data) => {
 function isTraversable(value) {
     return Array.isArray(value) || (isObject(value) && !objectHasFunction(value));
 }
-function markFieldsDirty(data, fields = {}) {
+function isRegisteredLeaf(fieldRef) {
+    return !!(fieldRef && '_f' in fieldRef);
+}
+function isEmptyDirtyContainer(value) {
+    return Array.isArray(value)
+        ? !value.some((item) => !isUndefined(item))
+        : !Object.keys(value).length;
+}
+function clearDirtyField(container, key) {
+    if (Array.isArray(container)) {
+        container[key] = undefined;
+    }
+    else {
+        delete container[key];
+    }
+}
+function markFieldsDirty(data, fields = {}, fieldRefs) {
     for (const key in data) {
         const value = data[key];
-        if (isTraversable(value)) {
+        const fieldRef = fieldRefs && fieldRefs[key];
+        if (isTraversable(value) &&
+            (!Array.isArray(value) || !isRegisteredLeaf(fieldRef))) {
             fields[key] = Array.isArray(value) ? [] : {};
-            markFieldsDirty(value, fields[key]);
+            markFieldsDirty(value, fields[key], fieldRef);
+            if (isEmptyDirtyContainer(fields[key])) {
+                clearDirtyField(fields, key);
+            }
         }
         else if (!isUndefined(value)) {
             fields[key] = true;
@@ -325,63 +418,51 @@ function markFieldsDirty(data, fields = {}) {
     }
     return fields;
 }
-function pruneDirtyFields(value) {
-    if (value === false) {
-        return undefined;
-    }
-    if (value === true) {
-        return true;
-    }
-    if (Array.isArray(value)) {
-        const result = value.map((value) => pruneDirtyFields(value));
-        return (result.some((value) => value !== undefined) ? result : undefined);
-    }
-    if (isObject(value)) {
-        const result = {};
-        for (const key in value) {
-            const pruned = pruneDirtyFields(value[key]);
-            if (!isUndefined(pruned)) {
-                result[key] = pruned;
-            }
-        }
-        return (Object.keys(result).length ? result : undefined);
-    }
-    return undefined;
-}
-function getDirtyFields(data, formValues, dirtyFieldsFromValues) {
+function getDirtyFields(data, formValues, dirtyFieldsFromValues, fieldRefs) {
     if (!dirtyFieldsFromValues) {
-        dirtyFieldsFromValues = markFieldsDirty(formValues);
+        dirtyFieldsFromValues = markFieldsDirty(formValues, {}, fieldRefs);
     }
     for (const key in data) {
         const value = data[key];
-        if (isTraversable(value)) {
+        const fieldRef = fieldRefs && fieldRefs[key];
+        if (isTraversable(value) &&
+            (!Array.isArray(value) || !isRegisteredLeaf(fieldRef))) {
             if (isUndefined(formValues) || isPrimitive(dirtyFieldsFromValues[key])) {
-                dirtyFieldsFromValues[key] = markFieldsDirty(value, Array.isArray(value) ? [] : {});
+                dirtyFieldsFromValues[key] = markFieldsDirty(value, Array.isArray(value) ? [] : {}, fieldRef);
             }
             else {
-                getDirtyFields(value, isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key]);
+                getDirtyFields(value, isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key], fieldRef);
             }
+            if (isEmptyDirtyContainer(dirtyFieldsFromValues[key])) {
+                clearDirtyField(dirtyFieldsFromValues, key);
+            }
+        }
+        else if (deepEqual(value, formValues[key])) {
+            clearDirtyField(dirtyFieldsFromValues, key);
         }
         else {
-            const formValue = formValues[key];
-            dirtyFieldsFromValues[key] = !deepEqual(value, formValue);
+            dirtyFieldsFromValues[key] = true;
         }
     }
-    return pruneDirtyFields(dirtyFieldsFromValues) || {};
+    return dirtyFieldsFromValues;
 }
 
 var getEventValue = (event) => isObject(event) && event.target
     ? isCheckBoxInput(event.target)
         ? event.target.checked
-        : event.target.value
+        : isFileInput(event.target)
+            ? event.target.files
+            : event.target.value
     : event;
 
-var getFieldArrayParentNames = (names, name) => {
-    const parts = name.split('.');
+var getFieldArrayItemNames = (names, name) => {
+    const segments = name.split('.');
     const matches = [];
-    let prefix = parts[0];
-    for (let i = 1; i < parts.length; prefix += '.' + parts[i++]) {
-        !isNaN(+parts[i]) && names.has(prefix) && matches.push(prefix);
+    let prefix = segments[0];
+    for (let i = 1; i < segments.length; prefix += '.' + segments[i++]) {
+        if (!isNaN(+segments[i]) && names.has(prefix)) {
+            matches.push(`${prefix}.${segments[i]}`);
+        }
     }
     return matches;
 };
@@ -392,23 +473,25 @@ const defaultResult = {
 };
 const validResult = { value: true, isValid: true };
 var getCheckboxValue = (options) => {
-    if (Array.isArray(options)) {
-        if (options.length > 1) {
-            const values = options
-                .filter((option) => option && option.checked && !option.disabled)
-                .map((option) => option.value);
-            return { value: values, isValid: !!values.length };
-        }
-        return options[0].checked && !options[0].disabled
-            ? // @ts-expect-error expected to work in the browser
-                options[0].attributes && !isUndefined(options[0].attributes.value)
-                    ? isUndefined(options[0].value) || options[0].value === ''
-                        ? validResult
-                        : { value: options[0].value, isValid: true }
-                    : validResult
-            : defaultResult;
-    }
-    return defaultResult;
+    if (!Array.isArray(options)) {
+        return defaultResult;
+    }
+    if (options.length > 1) {
+        const values = options
+            .filter((option) => option && option.checked && !option.disabled)
+            .map((option) => option.value);
+        return { value: values, isValid: !!values.length };
+    }
+    const option = options[0];
+    if (!option || !option.checked || option.disabled) {
+        return defaultResult;
+    }
+    if (!option.attributes || !('value' in option.attributes)) {
+        return validResult;
+    }
+    return isUndefined(option.value) || option.value === ''
+        ? validResult
+        : { value: option.value, isValid: true };
 };
 
 var getFieldValueAs = (value, { valueAsNumber, valueAsDate, setValueAs }) => isUndefined(value)
@@ -452,7 +535,7 @@ function getFieldValue(_f) {
     if (isCheckBoxInput(ref)) {
         return getCheckboxValue(_f.refs).value;
     }
-    return getFieldValueAs(isUndefined(ref.value) ? _f.ref.value : ref.value, _f);
+    return getFieldValueAs(ref.value, _f);
 }
 
 var getResolverOptions = (fieldsNames, _fields, criteriaMode, shouldUseNativeValidation) => {
@@ -490,49 +573,73 @@ var getValidationModes = (mode) => ({
 });
 
 const ASYNC_FUNCTION = 'AsyncFunction';
-var hasPromiseValidation = (fieldReference) => !!fieldReference &&
-    !!fieldReference.validate &&
-    !!((isFunction(fieldReference.validate) &&
-        fieldReference.validate.constructor.name === ASYNC_FUNCTION) ||
-        (isObject(fieldReference.validate) &&
-            Object.values(fieldReference.validate).find((validateFunction) => validateFunction.constructor.name === ASYNC_FUNCTION)));
+var hasPromiseValidation = (fieldReference) => {
+    if (!fieldReference || !fieldReference.validate)
+        return false;
+    if (isFunction(fieldReference.validate)) {
+        return fieldReference.validate.constructor.name === ASYNC_FUNCTION;
+    }
+    if (isObject(fieldReference.validate)) {
+        for (const key in fieldReference.validate) {
+            if (fieldReference.validate[key].constructor
+                .name === ASYNC_FUNCTION) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
 
 var hasValidation = (options) => options.mount &&
     (options.required ||
-        options.min ||
-        options.max ||
-        options.maxLength ||
-        options.minLength ||
+        (!isUndefined(options.required) && options.required !== false) ||
+        !isUndefined(options.min) ||
+        !isUndefined(options.max) ||
+        !isUndefined(options.maxLength) ||
+        !isUndefined(options.minLength) ||
         options.pattern ||
         options.validate);
 
-var isWatched = (name, _names, isBlurEvent) => !isBlurEvent &&
-    (_names.watchAll ||
-        _names.watch.has(name) ||
-        [..._names.watch].some((watchName) => name.startsWith(watchName) &&
-            /^\.\w+/.test(name.slice(watchName.length))));
+var isNameInFieldArray = (names, name) => name
+    .split('.')
+    .some((part, index, arr) => !isNaN(Number(part)) && names.has(arr.slice(0, index).join('.')));
+
+var isWatched = (name, _names, isBlurEvent) => {
+    if (isBlurEvent)
+        return false;
+    if (_names.watchAll || _names.watch.has(name))
+        return true;
+    for (const watchName of _names.watch) {
+        if (name.startsWith(watchName) && name.charAt(watchName.length) === '.')
+            return true;
+    }
+    return false;
+};
 
-const iterateFieldsByAction = (fields, action, fieldsNames, abortEarly) => {
+const iterateFieldsByAction = (fields, action, fieldsNames) => {
     for (const key of fieldsNames || Object.keys(fields)) {
-        const field = get(fields, key);
+        if (key === '_f') {
+            continue;
+        }
+        const field = fieldsNames ? get(fields, key) : fields[key];
         if (field) {
-            const { _f, ...currentField } = field;
+            const { _f } = field;
             if (_f) {
-                if (_f.refs && _f.refs[0] && action(_f.refs[0], key) && !abortEarly) {
+                if (_f.refs && _f.refs[0] && action(_f.refs[0], _f.name)) {
                     return true;
                 }
-                else if (_f.ref && action(_f.ref, _f.name) && !abortEarly) {
+                else if (_f.ref && action(_f.ref, _f.name)) {
                     return true;
                 }
                 else {
-                    if (iterateFieldsByAction(currentField, action)) {
-                        break;
+                    if (iterateFieldsByAction(field, action)) {
+                        return true;
                     }
                 }
             }
-            else if (isObject(currentField)) {
-                if (iterateFieldsByAction(currentField, action)) {
-                    break;
+            else if (isObject(field) || Array.isArray(field)) {
+                if (iterateFieldsByAction(field, action)) {
+                    return true;
                 }
             }
         }
@@ -542,7 +649,7 @@ const iterateFieldsByAction = (fields, action, fieldsNames, abortEarly) => {
 
 function schemaErrorLookup(errors, _fields, name) {
     const error = get(errors, name);
-    if (error || isKey(name)) {
+    if (error?.type || error?.message || Array.isArray(error)) {
         return {
             error,
             name,
@@ -577,11 +684,10 @@ function schemaErrorLookup(errors, _fields, name) {
 
 var shouldRenderFormState = (formStateData, _proxyFormState, updateFormState, isRoot) => {
     updateFormState(formStateData);
-    const { name, ...formState } = formStateData;
-    return (isEmptyObject(formState) ||
-        (isRoot &&
-            Object.keys(formState).length >= Object.keys(_proxyFormState).length) ||
-        Object.keys(formState).find((key) => _proxyFormState[key] ===
+    const keys = Object.keys(formStateData).filter((key) => key !== 'name');
+    return (!keys.length ||
+        (isRoot && keys.length >= Object.keys(_proxyFormState).length) ||
+        keys.find((key) => _proxyFormState[key] ===
             (!isRoot || VALIDATION_MODE.all)));
 };
 
@@ -590,7 +696,7 @@ var shouldSubscribeByName = (name, signalName, exact) => !name ||
     name === signalName ||
     convertToArrayPayload(name).some((currentName) => currentName &&
         (exact
-            ? currentName === signalName
+            ? currentName === signalName || currentName.startsWith(signalName + '.')
             : currentName.startsWith(signalName) ||
                 signalName.startsWith(currentName)));
 
@@ -610,10 +716,16 @@ var skipValidation = (isBlurEvent, isTouched, isSubmitted, reValidateMode, mode)
     return true;
 };
 
-var unsetEmptyArray = (ref, name) => !compact(get(ref, name)).length && unset(ref, name);
+var unsetEmptyArray = (ref, name) => {
+    const array = get(ref, name);
+    !compact(array).length &&
+        !array?.root &&
+        unset(ref, name);
+};
 
 var updateFieldArrayRootError = (errors, error, name) => {
-    const fieldArrayErrors = convertToArrayPayload(get(errors, name));
+    const existingErrors = get(errors, name);
+    const fieldArrayErrors = Array.isArray(existingErrors) ? existingErrors : [];
     set(fieldArrayErrors, ROOT_ERROR_TYPE, error[name]);
     set(errors, name, fieldArrayErrors);
     return errors;
@@ -639,7 +751,7 @@ var getValueAndMessage = (validationData) => isObject(validationData) && !isRege
     };
 
 var validateField = async (field, disabledFieldNames, formValues, validateAllFieldCriteria, shouldUseNativeValidation, isFieldArray) => {
-    const { ref, refs, required, maxLength, minLength, min, max, pattern, validate, name, valueAsNumber, mount, } = field._f;
+    const { ref, refs, required, maxLength, minLength, min, max, pattern, validate, name, valueAsNumber, mount, _c, } = field._f;
     const inputValue = get(formValues, name);
     if (!mount || disabledFieldNames.has(name)) {
         return {};
@@ -647,7 +759,14 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
     const inputRef = refs ? refs[0] : ref;
     const setCustomValidity = (message) => {
         if (shouldUseNativeValidation && inputRef.reportValidity) {
-            inputRef.setCustomValidity(isBoolean(message) ? '' : message || '');
+            const validityMessage = isBoolean(message) ? '' : message || '';
+            if (refs) {
+                refs.forEach((ref) => isFunction(ref.setCustomValidity) &&
+                    ref.setCustomValidity(validityMessage));
+            }
+            else {
+                inputRef.setCustomValidity(validityMessage);
+            }
             inputRef.reportValidity();
         }
     };
@@ -658,10 +777,9 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
     const isEmpty = ((valueAsNumber || isFileInput(ref)) &&
         isUndefined(ref.value) &&
         isUndefined(inputValue)) ||
-        (isHTMLElement(ref) && ref.value === '') ||
+        (isHTMLElement(ref) && ref.value === '' && !_c) ||
         inputValue === '' ||
-        (Array.isArray(inputValue) && !inputValue.length) ||
-        (valueAsNumber && typeof inputValue === 'number' && isNaN(inputValue));
+        (Array.isArray(inputValue) && !inputValue.length);
     const appendErrorsCurry = appendErrors.bind(null, name, validateAllFieldCriteria, error);
     const getMinMaxMessage = (exceedMax, maxLengthMessage, minLengthMessage, maxType = INPUT_VALIDATION_RULES.maxLength, minType = INPUT_VALIDATION_RULES.minLength) => {
         const message = exceedMax ? maxLengthMessage : minLengthMessage;
@@ -700,7 +818,9 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
         let exceedMin;
         const maxOutput = getValueAndMessage(max);
         const minOutput = getValueAndMessage(min);
-        if (!isNullOrUndefined(inputValue) && !isNaN(inputValue)) {
+        if (!isNullOrUndefined(inputValue) &&
+            !isDateObject(inputValue) &&
+            !isNaN(inputValue)) {
             const valueNumber = ref.valueAsNumber ||
                 (inputValue ? +inputValue : inputValue);
             if (!isNullOrUndefined(maxOutput.value)) {
@@ -797,7 +917,9 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
                         ...validateError,
                         ...appendErrorsCurry(key, validateError.message),
                     };
-                    setCustomValidity(validateError.message);
+                    if (!validateAllFieldCriteria) {
+                        setCustomValidity(validateError.message);
+                    }
                     if (validateAllFieldCriteria) {
                         error[name] = validationResult;
                     }
@@ -814,7 +936,8 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
             }
         }
     }
-    setCustomValidity(true);
+    const fieldError = error[name];
+    setCustomValidity(fieldError ? fieldError.message : true);
     return error;
 };
 
@@ -823,6 +946,14 @@ const defaultOptions = {
     reValidateMode: VALIDATION_MODE.onChange,
     shouldFocusError: true,
 };
+const updateDirtyFields = (dirtyFields, nextDirtyFields) => {
+    for (const key in dirtyFields) {
+        if (!(key in nextDirtyFields)) {
+            delete dirtyFields[key];
+        }
+    }
+    Object.assign(dirtyFields, nextDirtyFields);
+};
 const DEFAULT_FORM_STATE = {
     submitCount: 0,
     isDirty: false,
@@ -856,6 +987,7 @@ function createFormControl(props = {}) {
         : cloneObject(_defaultValues);
     let _state = {
         action: false,
+        actionArrayLengths: new Map(),
         mount: false,
         watch: false,
         keepIsValid: false,
@@ -868,8 +1000,11 @@ function createFormControl(props = {}) {
         watch: new Set(),
         registerName: new Set(),
     };
-    let delayErrorCallback;
-    let timer = 0;
+    const delayErrorCallbacks = {};
+    const timers = {};
+    let _valuesSubscriberCount = 0;
+    let _validationModeBeforeSubmit = getValidationModes(_options.mode);
+    let _validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
     const defaultProxyFormState = {
         isDirty: false,
         dirtyFields: false,
@@ -885,27 +1020,40 @@ function createFormControl(props = {}) {
     let _proxySubscribeFormState = {
         ..._proxyFormState,
     };
+    const _isTracked = (...keys) => keys.some((key) => _proxyFormState[key] || _proxySubscribeFormState[key]);
     const _subjects = {
         array: createSubject(),
         state: createSubject(),
     };
-    const shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;
-    const debounce = (callback) => (wait) => {
-        clearTimeout(timer);
-        timer = setTimeout(callback, wait);
+    let _setValidCallId = 0;
+    let _resetCallId = 0;
+    let shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;
+    const debounce = (name, callback) => (wait) => {
+        clearTimeout(timers[name]);
+        timers[name] = setTimeout(callback, wait);
+    };
+    const cancelDelayedError = (name) => {
+        clearTimeout(timers[name]);
+        delete timers[name];
+        delete delayErrorCallbacks[name];
+    };
+    const cancelDelayedErrorTree = (name) => {
+        cancelDelayedError(name);
+        const prefix = `${name}.`;
+        for (const key of Object.keys(delayErrorCallbacks)) {
+            key.startsWith(prefix) && cancelDelayedError(key);
+        }
     };
     const _setValid = async (shouldUpdateValid) => {
         if (_state.keepIsValid) {
             return;
         }
-        if (!_options.disabled &&
-            (_proxyFormState.isValid ||
-                _proxySubscribeFormState.isValid ||
-                shouldUpdateValid)) {
+        if (!_options.disabled && (_isTracked('isValid') || shouldUpdateValid)) {
+            const callId = ++_setValidCallId;
             let isValid;
             if (_options.resolver) {
                 isValid = isEmptyObject((await _runSchema()).errors);
-                _updateIsValidating();
+                callId === _setValidCallId && _updateIsValidating();
             }
             else {
                 isValid = await executeBuiltInValidation({
@@ -914,7 +1062,7 @@ function createFormControl(props = {}) {
                     eventType: EVENTS.VALID,
                 });
             }
-            if (isValid !== _formState.isValid) {
+            if (callId === _setValidCallId && isValid !== _formState.isValid) {
                 _subjects.state.next({
                     isValid,
                 });
@@ -922,12 +1070,8 @@ function createFormControl(props = {}) {
         }
     };
     const _updateIsValidating = (names, isValidating) => {
-        if (!_options.disabled &&
-            (_proxyFormState.isValidating ||
-                _proxyFormState.validatingFields ||
-                _proxySubscribeFormState.isValidating ||
-                _proxySubscribeFormState.validatingFields)) {
-            (names || Array.from(_names.mount)).forEach((name) => {
+        if (!_options.disabled && _isTracked('isValidating', 'validatingFields')) {
+            (names || _names.mount).forEach((name) => {
                 if (name) {
                     isValidating
                         ? set(_formState.validatingFields, name, isValidating)
@@ -941,35 +1085,50 @@ function createFormControl(props = {}) {
         }
     };
     const _updateDirtyFields = () => {
-        _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
+        _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues, undefined, _fields);
     };
     const _setFieldArray = (name, values = [], method, args, shouldSetValues = true, shouldUpdateFieldsAndState = true) => {
         if (args && method && !_options.disabled) {
             _state.action = true;
-            if (shouldUpdateFieldsAndState && Array.isArray(get(_fields, name))) {
-                const fieldValues = method(get(_fields, name), args.argA, args.argB);
+            const fields = get(_fields, name);
+            if (!_state.actionArrayLengths.has(name)) {
+                _state.actionArrayLengths.set(name, Array.isArray(fields) ? fields.length : 0);
+            }
+            if (shouldUpdateFieldsAndState && Array.isArray(fields)) {
+                const fieldValues = method(fields, args.argA, args.argB);
                 shouldSetValues && set(_fields, name, fieldValues);
             }
-            if (shouldUpdateFieldsAndState &&
-                Array.isArray(get(_formState.errors, name))) {
-                const errors = method(get(_formState.errors, name), args.argA, args.argB);
+            const fieldArrayErrors = get(_formState.errors, name);
+            if (shouldUpdateFieldsAndState && Array.isArray(fieldArrayErrors)) {
+                const rootError = fieldArrayErrors.root;
+                const errors = method(fieldArrayErrors, args.argA, args.argB) || fieldArrayErrors;
+                if (rootError) {
+                    errors.root = rootError;
+                }
                 shouldSetValues && set(_formState.errors, name, errors);
                 unsetEmptyArray(_formState.errors, name);
             }
-            if ((_proxyFormState.touchedFields ||
-                _proxySubscribeFormState.touchedFields) &&
-                shouldUpdateFieldsAndState &&
-                Array.isArray(get(_formState.touchedFields, name))) {
-                const touchedFields = method(get(_formState.touchedFields, name), args.argA, args.argB);
+            const touchedFieldsArray = get(_formState.touchedFields, name);
+            const shouldUpdateTouchedFields = shouldUpdateFieldsAndState && Array.isArray(touchedFieldsArray);
+            if (shouldUpdateTouchedFields) {
+                const touchedFields = method(touchedFieldsArray, args.argA, args.argB);
                 shouldSetValues && set(_formState.touchedFields, name, touchedFields);
             }
-            if (_proxyFormState.dirtyFields || _proxySubscribeFormState.dirtyFields) {
+            const dirtyFieldsArray = get(_formState.dirtyFields, name);
+            if (shouldUpdateFieldsAndState && Array.isArray(dirtyFieldsArray)) {
+                const dirtyFields = method(dirtyFieldsArray, args.argA, args.argB) || dirtyFieldsArray;
+                shouldSetValues && set(_formState.dirtyFields, name, dirtyFields);
+            }
+            if (_isTracked('dirtyFields')) {
                 _updateDirtyFields();
             }
             _subjects.state.next({
                 name,
                 isDirty: _getDirty(name, values),
                 dirtyFields: _formState.dirtyFields,
+                ...(shouldUpdateTouchedFields && {
+                    touchedFields: _formState.touchedFields,
+                }),
                 errors: _formState.errors,
                 isValid: _formState.isValid,
             });
@@ -980,16 +1139,20 @@ function createFormControl(props = {}) {
     };
     const updateErrors = (name, error) => {
         set(_formState.errors, name, error);
+        _formState.errors = { ..._formState.errors };
         _subjects.state.next({
             errors: _formState.errors,
         });
     };
     const _setErrors = (errors) => {
+        Object.keys(delayErrorCallbacks).forEach(cancelDelayedError);
+        const hasErrors = !isEmptyObject(errors);
         _formState.errors = errors;
         _subjects.state.next({
             errors: _formState.errors,
-            isValid: false,
+            ...(hasErrors ? { isValid: false } : {}),
         });
+        !hasErrors && _state.mount && _setValid();
     };
     const hasExplicitNullIntermediate = (name) => {
         const segments = isKey(name) ? [name] : stringToPath(name);
@@ -1007,10 +1170,46 @@ function createFormControl(props = {}) {
         }
         return false;
     };
+    const isStaleArrayField = (name) => {
+        if (!_state.actionArrayLengths.size) {
+            return false;
+        }
+        const segments = isKey(name) ? [name] : stringToPath(name);
+        let node = _formValues;
+        let path = '';
+        let ownerDepth = -1;
+        let ownerPreActionLength = 0;
+        for (let i = 0; i < segments.length; i++) {
+            if (isNullOrUndefined(node)) {
+                return false;
+            }
+            const key = segments[i];
+            path = path ? `${path}.${key}` : key;
+            if (Array.isArray(node) && +key >= node.length) {
+                return ownerDepth === -1
+                    ? false
+                    : i === ownerDepth
+                        ? +key < ownerPreActionLength
+                        : true;
+            }
+            if (_state.actionArrayLengths.has(path)) {
+                ownerDepth = i + 1;
+                ownerPreActionLength = _state.actionArrayLengths.get(path);
+            }
+            node = node[key];
+            if (isUndefined(node) &&
+                ownerDepth !== -1 &&
+                i > ownerDepth &&
+                +segments[ownerDepth] < ownerPreActionLength) {
+                return true;
+            }
+        }
+        return false;
+    };
     const updateValidAndValue = (name, shouldSkipSetValueAs, value, ref) => {
         const field = get(_fields, name);
         if (field) {
-            if (hasExplicitNullIntermediate(name)) {
+            if (hasExplicitNullIntermediate(name) || isStaleArrayField(name)) {
                 return;
             }
             const wasUnsetInFormValues = isUndefined(get(_formValues, name));
@@ -1021,22 +1220,28 @@ function createFormControl(props = {}) {
                 ? set(_formValues, name, shouldSkipSetValueAs ? defaultValue : getFieldValue(field._f))
                 : setFieldValue(name, defaultValue);
             if (_state.mount && !_state.action) {
-                _setValid();
-                // Re-registering a field after a prior unregister puts its key back
-                // into _formValues, which can flip isDirty back to false (#13397).
-                // Only run when we are currently dirty, otherwise an initial register
-                // for a field with no defaultValue would flip isDirty to true. Reset
-                // paths repopulate _formValues before re-register, so the key is
-                // present then and this branch is skipped (preserves keepDirty).
+                if (_options.resolver &&
+                    _isTracked('isValidating', 'validatingFields')) {
+                    Promise.resolve().then(() => _setValid());
+                }
+                else {
+                    _setValid();
+                }
                 if (wasUnsetInFormValues &&
                     _formState.isDirty &&
-                    (_proxyFormState.isDirty || _proxySubscribeFormState.isDirty)) {
+                    _isTracked('isDirty')) {
                     const isDirty = _getDirty();
                     if (!isDirty) {
                         _formState.isDirty = false;
                         _subjects.state.next({ ..._formState });
                     }
                 }
+                if (props.shouldUnregister &&
+                    wasUnsetInFormValues &&
+                    !isUndefined(get(_formValues, name)) &&
+                    isWatched(name, _names)) {
+                    _state.watch = true;
+                }
             }
         }
     };
@@ -1046,17 +1251,20 @@ function createFormControl(props = {}) {
         const output = {
             name,
         };
-        if (!_options.disabled) {
+        // an explicit programmatic update (e.g. setValue with shouldDirty: true)
+        // opts into dirty tracking even when the form is disabled
+        if (!_options.disabled || shouldDirty === true) {
             if (!isBlurEvent || shouldDirty) {
-                if (_proxyFormState.isDirty || _proxySubscribeFormState.isDirty) {
+                const isCurrentFieldPristine = deepEqual(get(_defaultValues, name), fieldValue);
+                if (_isTracked('isDirty')) {
                     isPreviousDirty = _formState.isDirty;
-                    _formState.isDirty = output.isDirty = _getDirty();
+                    _formState.isDirty = output.isDirty =
+                        !isCurrentFieldPristine || _getDirty();
                     shouldUpdateField = isPreviousDirty !== output.isDirty;
                 }
-                const isCurrentFieldPristine = deepEqual(get(_defaultValues, name), fieldValue);
                 isPreviousDirty = !!get(_formState.dirtyFields, name);
                 if (isCurrentFieldPristine !== _formState.isDirty) {
-                    _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
+                    updateDirtyFields(_formState.dirtyFields, getDirtyFields(_defaultValues, _formValues, undefined, _fields));
                 }
                 else {
                     isCurrentFieldPristine
@@ -1066,8 +1274,7 @@ function createFormControl(props = {}) {
                 output.dirtyFields = _formState.dirtyFields;
                 shouldUpdateField =
                     shouldUpdateField ||
-                        ((_proxyFormState.dirtyFields ||
-                            _proxySubscribeFormState.dirtyFields) &&
+                        (_isTracked('dirtyFields') &&
                             isPreviousDirty !== !isCurrentFieldPristine);
             }
             if (isBlurEvent) {
@@ -1077,8 +1284,7 @@ function createFormControl(props = {}) {
                     output.touchedFields = _formState.touchedFields;
                     shouldUpdateField =
                         shouldUpdateField ||
-                            ((_proxyFormState.touchedFields ||
-                                _proxySubscribeFormState.touchedFields) &&
+                            (_isTracked('touchedFields') &&
                                 isPreviousFieldTouched !== isBlurEvent);
                 }
             }
@@ -1088,19 +1294,19 @@ function createFormControl(props = {}) {
     };
     const shouldRenderByError = (name, isValid, error, fieldState) => {
         const previousFieldError = get(_formState.errors, name);
-        const shouldUpdateValid = (_proxyFormState.isValid || _proxySubscribeFormState.isValid) &&
+        const shouldUpdateValid = _isTracked('isValid') &&
             isBoolean(isValid) &&
             _formState.isValid !== isValid;
         if (_options.delayError && error) {
-            delayErrorCallback = debounce(() => updateErrors(name, error));
-            delayErrorCallback(_options.delayError);
+            delayErrorCallbacks[name] = debounce(name, () => updateErrors(name, error));
+            delayErrorCallbacks[name](_options.delayError);
         }
         else {
-            clearTimeout(timer);
-            delayErrorCallback = null;
+            cancelDelayedError(name);
             error
                 ? set(_formState.errors, name, error)
                 : unset(_formState.errors, name);
+            _formState.errors = { ..._formState.errors };
         }
         if ((error ? !deepEqual(previousFieldError, error) : previousFieldError) ||
             !isEmptyObject(fieldState) ||
@@ -1111,10 +1317,6 @@ function createFormControl(props = {}) {
                 errors: _formState.errors,
                 name,
             };
-            _formState = {
-                ..._formState,
-                ...updatedFormState,
-            };
             _subjects.state.next(updatedFormState);
         }
     };
@@ -1123,52 +1325,76 @@ function createFormControl(props = {}) {
         return await _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation));
     };
     const executeSchemaAndUpdateState = async (names) => {
+        const resetCallId = _resetCallId;
         const { errors } = await _runSchema(names);
+        if (resetCallId !== _resetCallId) {
+            return errors;
+        }
         _updateIsValidating(names);
         if (names) {
             for (const name of names) {
                 const error = get(errors, name);
-                error
-                    ? _names.array.has(name) && isObject(error)
-                        ? updateFieldArrayRootError(_formState.errors, { [name]: error }, name)
-                        : set(_formState.errors, name, error)
-                    : unset(_formState.errors, name);
-            }
+                cancelDelayedErrorTree(name);
+                const isFieldArrayRootError = _names.array.has(name) &&
+                    isObject(error) &&
+                    !Object.keys(error).some((key) => !Number.isNaN(Number(key)));
+                const field = get(_fields, name);
+                const hasNestedFields = isObject(field) && Object.keys(field).some((key) => key !== '_f');
+                isFieldArrayRootError
+                    ? updateFieldArrayRootError(_formState.errors, { [name]: error }, name)
+                    : error?.type ||
+                        error?.message ||
+                        Array.isArray(error) ||
+                        (isObject(error) && hasNestedFields)
+                        ? set(_formState.errors, name, error)
+                        : unset(_formState.errors, name);
+            }
+            _formState.errors = { ..._formState.errors };
         }
         else {
+            Object.keys(delayErrorCallbacks).forEach(cancelDelayedError);
             _formState.errors = errors;
         }
         return errors;
     };
     const validateForm = async ({ name, eventType, }) => {
-        if (props.validate) {
-            const result = await props.validate({
+        if (_options.validate) {
+            const resetCallId = _resetCallId;
+            const result = await _options.validate({
                 formValues: _formValues,
                 formState: _formState,
                 name,
                 eventType,
             });
+            if (resetCallId !== _resetCallId) {
+                return true;
+            }
             if (isObject(result)) {
+                let isValid = true;
+                clearErrors(FORM_ERROR_TYPE);
                 for (const key in result) {
                     const error = result[key];
                     if (error) {
+                        isValid = false;
                         setError(`${FORM_ERROR_TYPE}.${key}`, {
                             message: isString(error.message) ? error.message : '',
                             type: error.type || INPUT_VALIDATION_RULES.validate,
                         });
                     }
                 }
+                return isValid;
             }
             else if (isString(result) || !result) {
                 setError(FORM_ERROR_TYPE, {
                     message: result || '',
                     type: INPUT_VALIDATION_RULES.validate,
                 });
+                return false;
             }
             else {
                 clearErrors(FORM_ERROR_TYPE);
+                return true;
             }
-            return result;
         }
         return true;
     };
@@ -1176,7 +1402,8 @@ function createFormControl(props = {}) {
         valid: true,
         runRootValidation: false,
     }, }) => {
-        if (props.validate) {
+        const resetCallId = _resetCallId;
+        if (_options.validate && !context.runRootValidation) {
             context.runRootValidation = true;
             const result = await validateForm({
                 name,
@@ -1196,14 +1423,14 @@ function createFormControl(props = {}) {
                 if (_f) {
                     const isFieldArrayRoot = _names.array.has(_f.name);
                     const isPromiseFunction = field._f && hasPromiseValidation(field._f);
-                    const shouldTrackIsValidatingState = _proxyFormState.validatingFields ||
-                        _proxyFormState.isValidating ||
-                        _proxySubscribeFormState.validatingFields ||
-                        _proxySubscribeFormState.isValidating;
+                    const shouldTrackIsValidatingState = _isTracked('isValidating', 'validatingFields');
                     if (isPromiseFunction && shouldTrackIsValidatingState) {
                         _updateIsValidating([_f.name], true);
                     }
                     const fieldError = await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !onlyCheckValid, isFieldArrayRoot);
+                    if (resetCallId !== _resetCallId) {
+                        return context.valid;
+                    }
                     if (isPromiseFunction && shouldTrackIsValidatingState) {
                         _updateIsValidating([_f.name]);
                     }
@@ -1213,12 +1440,14 @@ function createFormControl(props = {}) {
                             break;
                         }
                     }
-                    !onlyCheckValid &&
-                        (get(fieldError, _f.name)
+                    if (!onlyCheckValid) {
+                        cancelDelayedError(_f.name);
+                        get(fieldError, _f.name)
                             ? isFieldArrayRoot
                                 ? updateFieldArrayRootError(_formState.errors, fieldError, _f.name)
                                 : set(_formState.errors, _f.name, fieldError[_f.name])
-                            : unset(_formState.errors, _f.name));
+                            : unset(_formState.errors, _f.name);
+                    }
                     if (props.shouldUseNativeValidation && fieldError[_f.name]) {
                         break;
                     }
@@ -1246,20 +1475,17 @@ function createFormControl(props = {}) {
         }
         _names.unMount = new Set();
     };
-    const _getDirty = (name, data) => !_options.disabled &&
-        (name && data && set(_formValues, name, data),
-            !deepEqual(getValues(), _defaultValues));
+    const _getDirty = (name, data) => (name && data && set(_formValues, name, data),
+        !deepEqual(_state.mount ? _formValues : _defaultValues, _defaultValues));
     const _getWatch = (names, defaultValue, isGlobal) => generateWatchOutput(names, _names, {
         ...(_state.mount
             ? _formValues
-            : isUndefined(defaultValue)
+            : isUndefined(defaultValue) || isString(names)
                 ? _defaultValues
-                : isString(names)
-                    ? { [names]: defaultValue }
-                    : defaultValue),
+                : defaultValue),
     }, isGlobal, defaultValue);
     const _getFieldArray = (name) => compact(get(_state.mount ? _formValues : _defaultValues, name, _options.shouldUnregister ? get(_defaultValues, name, []) : []));
-    const setFieldValue = (name, value, options = {}) => {
+    const setFieldValue = (name, value, options = {}, skipClone = false, skipRender = false, skipValueRender = false) => {
         const field = get(_fields, name);
         let fieldValue = value;
         if (field) {
@@ -1297,23 +1523,46 @@ function createFormControl(props = {}) {
                 }
                 else {
                     fieldReference.ref.value = fieldValue;
-                    if (!fieldReference.ref.type) {
+                    if (!fieldReference.ref.type && !skipRender && !skipValueRender) {
                         _subjects.state.next({
                             name,
-                            values: cloneObject(_formValues),
+                            values: skipClone ? _formValues : cloneObject(_formValues),
                         });
                     }
                 }
             }
         }
         (options.shouldDirty || options.shouldTouch) &&
-            updateTouchAndDirty(name, fieldValue, options.shouldTouch, options.shouldDirty, true);
-        options.shouldValidate && trigger(name);
+            updateTouchAndDirty(name, field &&
+                field._f &&
+                !field._f.disabled &&
+                (field._f.valueAsNumber ||
+                    field._f.valueAsDate ||
+                    field._f.setValueAs)
+                ? getFieldValueAs(value, field._f)
+                : fieldValue, options.shouldTouch, options.shouldDirty, !skipRender);
+        options.shouldValidate &&
+            trigger(name, {
+                delayError: options.delayError,
+            });
+        if (options.shouldValidate &&
+            field &&
+            field._f &&
+            field._f.deps &&
+            (!Array.isArray(field._f.deps) || field._f.deps.length > 0)) {
+            trigger(field._f.deps);
+        }
     };
-    const setFieldValues = (name, value, options) => {
+    const setFieldValues = (name, value, options, skipClone = false, skipRender = false, skipValueRender = false) => {
+        if (_names.array.has(name)) {
+            _subjects.array.next({
+                name,
+                values: skipClone ? _formValues : cloneObject(_formValues),
+            });
+        }
         for (const fieldKey in value) {
             if (!value.hasOwnProperty(fieldKey)) {
-                return;
+                continue;
             }
             const fieldValue = value[fieldKey];
             const fieldName = name + '.' + fieldKey;
@@ -1322,14 +1571,14 @@ function createFormControl(props = {}) {
                 isObject(fieldValue) ||
                 (field && !field._f)) &&
                 !isDateObject(fieldValue)
-                ? setFieldValues(fieldName, fieldValue, options)
-                : setFieldValue(fieldName, fieldValue, options);
+                ? setFieldValues(fieldName, fieldValue, options, skipClone, skipRender, skipValueRender)
+                : setFieldValue(fieldName, fieldValue, options, skipClone, skipRender, skipValueRender);
         }
     };
-    const setValue = (name, value, options = {}) => {
+    const _setValue = (name, value, options, skipClone, skipStateEmit = false) => {
         const field = get(_fields, name);
         const isFieldArray = _names.array.has(name);
-        const cloneValue = cloneObject(value);
+        const cloneValue = skipClone ? value : cloneObject(value);
         const previousValue = get(_formValues, name);
         const isValueUnchanged = deepEqual(previousValue, cloneValue);
         if (!isValueUnchanged) {
@@ -1338,47 +1587,51 @@ function createFormControl(props = {}) {
         if (isFieldArray) {
             _subjects.array.next({
                 name,
-                values: cloneObject(_formValues),
+                values: skipClone ? _formValues : cloneObject(_formValues),
             });
-            if ((_proxyFormState.isDirty ||
-                _proxyFormState.dirtyFields ||
-                _proxySubscribeFormState.isDirty ||
-                _proxySubscribeFormState.dirtyFields) &&
-                options.shouldDirty) {
+            if (_isTracked('isDirty', 'dirtyFields') && options.shouldDirty) {
                 _updateDirtyFields();
-                _subjects.state.next({
-                    name,
-                    dirtyFields: _formState.dirtyFields,
-                    isDirty: _getDirty(name, cloneValue),
-                });
+                if (!skipStateEmit) {
+                    _subjects.state.next({
+                        name,
+                        dirtyFields: _formState.dirtyFields,
+                        isDirty: _getDirty(name, cloneValue),
+                    });
+                }
             }
+            options.shouldValidate &&
+                trigger(name, {
+                    delayError: options.delayError,
+                });
         }
         else {
             const isEmpty = (Array.isArray(cloneValue) && !cloneValue.length) ||
                 isEmptyObject(cloneValue);
+            const skipValueRender = !isValueUnchanged && !skipStateEmit;
             if (!field || field._f || isNullOrUndefined(cloneValue) || isEmpty) {
-                setFieldValue(name, cloneValue, options);
+                setFieldValue(name, cloneValue, options, skipClone, skipStateEmit, skipValueRender);
             }
             else {
-                setFieldValues(name, cloneValue, options);
+                setFieldValues(name, cloneValue, options, skipClone, skipStateEmit, skipValueRender);
             }
         }
-        if (!isValueUnchanged) {
+        if (!isValueUnchanged && !skipStateEmit) {
             const watched = isWatched(name, _names);
-            const values = cloneObject(_formValues);
-            if (!isFieldArray) {
-                for (const arrayName of getFieldArrayParentNames(_names.array, name)) {
-                    _subjects.array.next({ name: arrayName, values });
-                }
-            }
+            const values = skipClone ? _formValues : cloneObject(_formValues);
             _subjects.state.next({
                 ...(watched && _formState),
                 name: _state.mount || watched ? name : undefined,
                 values,
             });
+            if (!isFieldArray) {
+                for (const itemName of getFieldArrayItemNames(_names.array, name)) {
+                    _subjects.state.next({ name: itemName, values });
+                }
+            }
         }
     };
-    const setValues = (formValues) => {
+    const setValue = (name, value, options = {}) => _setValue(name, value, options, false);
+    const setValues = (formValues, options = {}) => {
         const updatedFormValues = isFunction(formValues)
             ? formValues(_formValues)
             : formValues;
@@ -1388,9 +1641,19 @@ function createFormControl(props = {}) {
                 ...updatedFormValues,
             };
             for (const fieldName of _names.mount) {
-                setValue(fieldName, get(updatedFormValues, fieldName));
+                if (has(updatedFormValues, fieldName)) {
+                    _setValue(fieldName, get(updatedFormValues, fieldName), options, true, true);
+                }
+            }
+            _subjects.state.next({
+                ..._formState,
+                name: undefined,
+                type: undefined,
+                ...(_valuesSubscriberCount ? { values: _formValues } : {}),
+            });
+            if (options.shouldValidate) {
+                _setValid();
             }
-            _subjects.state.next({ ..._formState, values: _formValues });
         }
     };
     const onChange = async (event) => {
@@ -1405,8 +1668,6 @@ function createFormControl(props = {}) {
                     (isDateObject(fieldValue) && isNaN(fieldValue.getTime())) ||
                     deepEqual(fieldValue, get(_formValues, name, fieldValue));
         };
-        const validationModeBeforeSubmit = getValidationModes(_options.mode);
-        const validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
         if (field) {
             let error;
             let isValid;
@@ -1414,18 +1675,20 @@ function createFormControl(props = {}) {
                 ? getFieldValue(field._f)
                 : getEventValue(event);
             const isBlurEvent = event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;
-            const shouldSkipValidation = (!hasValidation(field._f) &&
-                !props.validate &&
+            const hasNoValidationEffect = !hasValidation(field._f) &&
+                !_options.validate &&
                 !_options.resolver &&
                 !get(_formState.errors, name) &&
-                !field._f.deps) ||
-                skipValidation(isBlurEvent, get(_formState.touchedFields, name), _formState.isSubmitted, validationModeAfterSubmit, validationModeBeforeSubmit);
+                !field._f.deps;
+            const shouldSkipValidation = hasNoValidationEffect ||
+                skipValidation(isBlurEvent, get(_formState.touchedFields, name), _formState.isSubmitted, _validationModeAfterSubmit, _validationModeBeforeSubmit);
             const watched = isWatched(name, _names, isBlurEvent);
-            set(_formValues, name, fieldValue);
+            set(_formValues, name, cloneObject(fieldValue));
             if (isBlurEvent) {
                 if (!target || !target.readOnly) {
                     field._f.onBlur && field._f.onBlur(event);
-                    delayErrorCallback && delayErrorCallback(0);
+                    const pendingDelayError = delayErrorCallbacks[name];
+                    pendingDelayError && pendingDelayError(0);
                 }
             }
             else if (field._f.onChange) {
@@ -1437,10 +1700,13 @@ function createFormControl(props = {}) {
                 _subjects.state.next({
                     name,
                     type: event.type,
-                    values: cloneObject(_formValues),
+                    ...(_valuesSubscriberCount
+                        ? { values: cloneObject(_formValues) }
+                        : {}),
                 });
             if (shouldSkipValidation) {
-                if (_proxyFormState.isValid || _proxySubscribeFormState.isValid) {
+                if ((!hasNoValidationEffect || !_formState.isValid) &&
+                    _isTracked('isValid')) {
                     if (_options.mode === 'onBlur') {
                         if (isBlurEvent) {
                             _setValid();
@@ -1453,7 +1719,7 @@ function createFormControl(props = {}) {
                 return (shouldRender &&
                     _subjects.state.next({ name, ...(watched ? {} : fieldState) }));
             }
-            if (!_options.resolver && props.validate) {
+            if (!_options.resolver && _options.validate) {
                 await validateForm({
                     name: name,
                     eventType: event.type,
@@ -1461,34 +1727,46 @@ function createFormControl(props = {}) {
             }
             !isBlurEvent && watched && _subjects.state.next({ ..._formState });
             if (_options.resolver) {
+                const resetCallId = _resetCallId;
                 const { errors } = await _runSchema([name]);
+                if (resetCallId !== _resetCallId) {
+                    return;
+                }
                 _updateIsValidating([name]);
                 _updateIsFieldValueUpdated(fieldValue);
-                if (isFieldValueUpdated) {
-                    const previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name);
-                    const errorLookupResult = schemaErrorLookup(errors, _fields, previousErrorLookupResult.name || name);
-                    error = errorLookupResult.error;
-                    name = errorLookupResult.name;
-                    isValid = isEmptyObject(errors);
+                if (!isFieldValueUpdated) {
+                    !isEmptyObject(fieldState) && _subjects.state.next(fieldState);
+                    return;
                 }
+                const previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name);
+                const errorLookupResult = schemaErrorLookup(errors, _fields, previousErrorLookupResult.name || name);
+                error = errorLookupResult.error;
+                name = errorLookupResult.name;
+                isValid = isEmptyObject(errors);
             }
             else {
+                const resetCallId = _resetCallId;
                 _updateIsValidating([name], true);
                 error = (await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation))[name];
+                if (resetCallId !== _resetCallId) {
+                    return;
+                }
                 _updateIsValidating([name]);
                 _updateIsFieldValueUpdated(fieldValue);
                 if (isFieldValueUpdated) {
                     if (error) {
                         isValid = false;
                     }
-                    else if (_proxyFormState.isValid ||
-                        _proxySubscribeFormState.isValid) {
+                    else if (_isTracked('isValid')) {
                         isValid = await executeBuiltInValidation({
                             fields: _fields,
                             onlyCheckValid: true,
                             name: name,
                             eventType: event.type,
                         });
+                        if (resetCallId !== _resetCallId) {
+                            return;
+                        }
                     }
                 }
             }
@@ -1512,11 +1790,15 @@ function createFormControl(props = {}) {
         let validationResult;
         const fieldNames = convertToArrayPayload(name);
         if (_options.resolver) {
+            const resetCallId = _resetCallId;
             const errors = await executeSchemaAndUpdateState(isUndefined(name) ? name : fieldNames);
             isValid = isEmptyObject(errors);
             validationResult = name
                 ? !fieldNames.some((name) => get(errors, name))
                 : isValid;
+            if (resetCallId !== _resetCallId) {
+                return validationResult;
+            }
         }
         else if (name) {
             validationResult = (await Promise.all(fieldNames.map(async (fieldName) => {
@@ -1535,13 +1817,32 @@ function createFormControl(props = {}) {
                 eventType: EVENTS.TRIGGER,
             });
         }
+        if (options.delayError && _options.delayError && isString(name)) {
+            const error = get(_formState.errors, name);
+            if (error) {
+                unset(_formState.errors, name);
+                delayErrorCallbacks[name] = debounce(name, () => updateErrors(name, error));
+                delayErrorCallbacks[name](_options.delayError);
+            }
+            else {
+                cancelDelayedError(name);
+            }
+        }
+        if (options.shouldTouch) {
+            for (const fieldName of name ? fieldNames : _names.mount) {
+                !_names.array.has(fieldName) &&
+                    set(_formState.touchedFields, fieldName, true);
+            }
+        }
         _subjects.state.next({
             ...(!isString(name) ||
-                ((_proxyFormState.isValid || _proxySubscribeFormState.isValid) &&
-                    isValid !== _formState.isValid)
+                (_isTracked('isValid') && isValid !== _formState.isValid)
                 ? {}
                 : { name }),
             ...(_options.resolver || !name ? { isValid } : {}),
+            ...(options.shouldTouch && _isTracked('touchedFields')
+                ? { touchedFields: _formState.touchedFields }
+                : {}),
             errors: _formState.errors,
         });
         options.shouldFocus &&
@@ -1562,20 +1863,28 @@ function createFormControl(props = {}) {
                 ? get(values, fieldNames)
                 : fieldNames.map((name) => get(values, name));
     };
-    const getFieldState = (name, formState) => ({
-        invalid: !!get((formState || _formState).errors, name),
-        isDirty: !!get((formState || _formState).dirtyFields, name),
-        error: get((formState || _formState).errors, name),
-        isValidating: !!get(_formState.validatingFields, name),
-        isTouched: !!get((formState || _formState).touchedFields, name),
-    });
+    const getErrors = (fieldNames) => isUndefined(fieldNames)
+        ? { ..._formState.errors }
+        : isString(fieldNames)
+            ? get(_formState.errors, fieldNames)
+            : fieldNames.map((name) => get(_formState.errors, name));
+    const getFieldState = (name, formState) => {
+        const targetFormState = formState || _formState;
+        const error = get(targetFormState.errors, name);
+        return {
+            invalid: !!error,
+            isDirty: !!get(targetFormState.dirtyFields, name),
+            error,
+            isValidating: !!get(targetFormState.validatingFields, name),
+            isTouched: !!get(targetFormState.touchedFields, name),
+        };
+    };
     const clearErrors = (name) => {
         const names = name ? convertToArrayPayload(name) : undefined;
-        names?.forEach((inputName) => unset(_formState.errors, inputName));
         if (names) {
-            // Emit for each cleared field with the field name so that
-            // shouldSubscribeByName can filter and avoid broad re-renders
             names.forEach((inputName) => {
+                cancelDelayedErrorTree(inputName);
+                unset(_formState.errors, inputName);
                 _subjects.state.next({
                     name: inputName,
                     errors: _formState.errors,
@@ -1583,17 +1892,18 @@ function createFormControl(props = {}) {
             });
         }
         else {
-            // Clear all errors - emit without name to notify all subscribers
+            Object.keys(delayErrorCallbacks).forEach(cancelDelayedError);
+            _formState.errors = {};
             _subjects.state.next({
-                errors: {},
+                errors: _formState.errors,
             });
         }
     };
     const setError = (name, error, options) => {
+        cancelDelayedErrorTree(name);
         const ref = (get(_fields, name, { _f: {} })._f || {}).ref;
         const currentError = get(_formState.errors, name) || {};
-        // Don't override existing error messages elsewhere in the object tree.
-        const { ref: currentRef, message, type, ...restOfErrorTree } = currentError;
+        const { ref: currentRef, message, type, types, ...restOfErrorTree } = currentError;
         set(_formState.errors, name, {
             ...restOfErrorTree,
             ...error,
@@ -1606,21 +1916,59 @@ function createFormControl(props = {}) {
         });
         options && options.shouldFocus && ref && ref.focus && ref.focus();
     };
-    const watch = (name, defaultValue) => _getWatch(name, defaultValue, true);
-    const _subscribe = (props) => _subjects.state.subscribe({
-        next: (formState) => {
-            if (shouldSubscribeByName(props.name, formState.name, props.exact) &&
-                shouldRenderFormState(formState, props.formState || _proxyFormState, _setFormState, props.reRenderRoot)) {
-                const snapshot = { ..._formValues };
-                props.callback({
-                    values: snapshot,
-                    ..._formState,
-                    ...formState,
-                    defaultValues: _defaultValues,
-                });
+    const watch = (name, defaultValue) => {
+        if (isFunction(name)) {
+            _valuesSubscriberCount++;
+            const { unsubscribe } = _subjects.state.subscribe({
+                next: (payload) => 'values' in payload &&
+                    name(payload.values || _getWatch(undefined, defaultValue), payload),
+            });
+            let called = false;
+            return {
+                unsubscribe: () => {
+                    if (called) {
+                        return;
+                    }
+                    called = true;
+                    _valuesSubscriberCount--;
+                    unsubscribe();
+                },
+            };
+        }
+        return _getWatch(name, defaultValue, true);
+    };
+    const _subscribe = (props) => {
+        const needsValues = !!props.formState?.values;
+        if (needsValues) {
+            _valuesSubscriberCount++;
+        }
+        const { unsubscribe } = _subjects.state.subscribe({
+            next: (formState) => {
+                if (shouldSubscribeByName(props.name, formState.name, props.exact) &&
+                    shouldRenderFormState(formState, props.formState || _proxyFormState, _setFormState, props.reRenderRoot)) {
+                    const snapshot = { ..._formValues };
+                    props.callback({
+                        values: snapshot,
+                        ..._formState,
+                        ...formState,
+                        defaultValues: _defaultValues,
+                    });
+                }
+            },
+        });
+        if (!needsValues) {
+            return unsubscribe;
+        }
+        let called = false;
+        return () => {
+            if (called) {
+                return;
             }
-        },
-    }).unsubscribe;
+            called = true;
+            _valuesSubscriberCount--;
+            unsubscribe();
+        };
+    };
     const subscribe = (props) => {
         _state.mount = true;
         _proxySubscribeFormState = {
@@ -1639,11 +1987,15 @@ function createFormControl(props = {}) {
         for (const fieldName of name ? convertToArrayPayload(name) : _names.mount) {
             _names.mount.delete(fieldName);
             _names.array.delete(fieldName);
+            _names.disabled.delete(fieldName);
             if (!options.keepValue) {
                 unset(_fields, fieldName);
                 unset(_formValues, fieldName);
             }
-            !options.keepError && unset(_formState.errors, fieldName);
+            if (!options.keepError) {
+                cancelDelayedErrorTree(fieldName);
+                unset(_formState.errors, fieldName);
+            }
             !options.keepDirty && unset(_formState.dirtyFields, fieldName);
             !options.keepTouched && unset(_formState.touchedFields, fieldName);
             !options.keepIsValidating &&
@@ -1652,12 +2004,16 @@ function createFormControl(props = {}) {
                 !options.keepDefaultValue &&
                 unset(_defaultValues, fieldName);
         }
-        _subjects.state.next({
-            values: cloneObject(_formValues),
-        });
+        _valuesSubscriberCount &&
+            _subjects.state.next({
+                values: cloneObject(_formValues),
+            });
         _subjects.state.next({
             ..._formState,
-            ...(!options.keepDirty ? {} : { isDirty: _getDirty() }),
+            ...(options.keepDirty ? {} : { isDirty: _getDirty() }),
+            ...(options.keepIsValidating
+                ? {}
+                : { isValidating: !isEmptyObject(_formState.validatingFields) }),
         });
         !options.keepIsValid && _setValid();
     };
@@ -1686,6 +2042,14 @@ function createFormControl(props = {}) {
             },
         });
         _names.mount.add(name);
+        if (field && field._f) {
+            const nextField = get(_fields, name);
+            for (const rule of REGISTER_VALIDATION_RULES) {
+                if (!(rule in options)) {
+                    delete nextField._f[rule];
+                }
+            }
+        }
         if (field && !shouldRevalidateRemount) {
             _setDisabledField({
                 disabled: isBoolean(options.disabled)
@@ -1732,20 +2096,23 @@ function createFormControl(props = {}) {
                         : fieldRef === field._f.ref) {
                         return;
                     }
+                    const newField = {
+                        ...field._f,
+                    };
+                    if (radioOrCheckbox) {
+                        newField.refs = [
+                            ...refs.filter(live),
+                            fieldRef,
+                            ...(Array.isArray(get(_defaultValues, name)) ? [{}] : []),
+                        ];
+                        newField.ref = { type: fieldRef.type, name };
+                    }
+                    else {
+                        newField.ref = fieldRef;
+                        delete newField.refs;
+                    }
                     set(_fields, name, {
-                        _f: {
-                            ...field._f,
-                            ...(radioOrCheckbox
-                                ? {
-                                    refs: [
-                                        ...refs.filter(live),
-                                        fieldRef,
-                                        ...(Array.isArray(get(_defaultValues, name)) ? [{}] : []),
-                                    ],
-                                    ref: { type: fieldRef.type, name },
-                                }
-                                : { ref: fieldRef }),
-                        },
+                        _f: newField,
                     });
                     updateValidAndValue(name, false, undefined, fieldRef);
                 }
@@ -1755,8 +2122,7 @@ function createFormControl(props = {}) {
                         field._f.mount = false;
                     }
                     (_options.shouldUnregister || options.shouldUnregister) &&
-                        !(getFieldArrayParentNames(_names.array, name).length &&
-                            _state.action) &&
+                        !(isNameInFieldArray(_names.array, name) && _state.action) &&
                         _names.unMount.add(name);
                 }
             },
@@ -1778,10 +2144,11 @@ function createFormControl(props = {}) {
                         });
                     }
                 }
-            }, 0, false);
+            }, 0);
         }
     };
     const handleSubmit = (onValid, onInvalid) => async (e) => {
+        let result = undefined;
         let onValidError = undefined;
         if (e) {
             e.preventDefault && e.preventDefault();
@@ -1793,29 +2160,38 @@ function createFormControl(props = {}) {
             isSubmitting: true,
         });
         if (_options.resolver) {
+            const resetCallId = _resetCallId;
             const { errors, values } = await _runSchema();
+            if (resetCallId !== _resetCallId) {
+                return;
+            }
             _updateIsValidating();
+            Object.keys(delayErrorCallbacks).forEach(cancelDelayedError);
             _formState.errors = errors;
             fieldValues = cloneObject(values);
         }
         else {
+            const resetCallId = _resetCallId;
             await executeBuiltInValidation({
                 fields: _fields,
                 eventType: EVENTS.SUBMIT,
             });
+            if (resetCallId !== _resetCallId) {
+                return;
+            }
+            unset(_formState.errors, ROOT_ERROR_TYPE);
         }
         if (_names.disabled.size) {
             for (const name of _names.disabled) {
                 unset(fieldValues, name);
             }
         }
-        unset(_formState.errors, ROOT_ERROR_TYPE);
         if (isEmptyObject(_formState.errors)) {
             _subjects.state.next({
                 errors: {},
             });
             try {
-                await onValid(fieldValues, e);
+                result = await onValid(fieldValues, e);
             }
             catch (error) {
                 onValidError = error;
@@ -1838,9 +2214,11 @@ function createFormControl(props = {}) {
         if (onValidError) {
             throw onValidError;
         }
+        return result;
     };
     const resetField = (name, options = {}) => {
         if (get(_fields, name)) {
+            unset(_formState.validatingFields, name);
             if (isUndefined(options.defaultValue)) {
                 setValue(name, cloneObject(get(_defaultValues, name)));
             }
@@ -1858,17 +2236,24 @@ function createFormControl(props = {}) {
                     : _getDirty();
             }
             if (!options.keepError) {
+                cancelDelayedErrorTree(name);
                 unset(_formState.errors, name);
-                _proxyFormState.isValid && _setValid();
+                _setValid();
             }
-            _subjects.state.next({ ..._formState });
+            _subjects.state.next({
+                ..._formState,
+                isValidating: !isEmptyObject(_formState.validatingFields),
+            });
         }
     };
     const _reset = (formValues, keepStateOptions = {}) => {
+        _resetCallId++;
         const updatedValues = formValues ? cloneObject(formValues) : _defaultValues;
         const cloneUpdatedValues = cloneObject(updatedValues);
         const isEmptyResetValues = isEmptyObject(formValues);
-        const values = isEmptyResetValues ? _defaultValues : cloneUpdatedValues;
+        const values = cloneUpdatedValues;
+        const fieldRefs = _fields;
+        Object.keys(delayErrorCallbacks).forEach(cancelDelayedError);
         if (!keepStateOptions.keepDefaultValues) {
             _defaultValues = updatedValues;
         }
@@ -1876,9 +2261,9 @@ function createFormControl(props = {}) {
             if (keepStateOptions.keepDirtyValues) {
                 const fieldsToCheck = new Set([
                     ..._names.mount,
-                    ...Object.keys(getDirtyFields(_defaultValues, _formValues)),
+                    ...collectDirtyFieldNames(getDirtyFields(_defaultValues, _formValues, undefined, fieldRefs), _formState.dirtyFields),
                 ]);
-                for (const fieldName of Array.from(fieldsToCheck)) {
+                for (const fieldName of fieldsToCheck) {
                     const isDirty = get(_formState.dirtyFields, fieldName);
                     const existingValue = get(_formValues, fieldName);
                     const newValue = get(values, fieldName);
@@ -1917,15 +2302,25 @@ function createFormControl(props = {}) {
                     _fields = {};
                 }
             }
-            _formValues = _options.shouldUnregister
-                ? keepStateOptions.keepDefaultValues
+            if (_options.shouldUnregister) {
+                _formValues = keepStateOptions.keepDefaultValues
                     ? cloneObject(_defaultValues)
-                    : {}
-                : cloneObject(values);
+                    : {};
+                if (keepStateOptions.keepFieldsRef) {
+                    for (const fieldName of _names.mount) {
+                        set(_formValues, fieldName, get(values, fieldName));
+                    }
+                }
+            }
+            else {
+                _formValues = cloneObject(values);
+            }
             _subjects.array.next({
                 values: { ...values },
             });
             _subjects.state.next({
+                name: undefined,
+                type: undefined,
                 values: { ...values },
             });
         }
@@ -1947,9 +2342,7 @@ function createFormControl(props = {}) {
         _state.watch = !!_options.shouldUnregister;
         _state.keepIsValid = !!keepStateOptions.keepIsValid;
         _state.action = false;
-        // Clear errors synchronously to prevent validation errors on subsequent submissions
-        // This fixes the issue where form.reset() causes validation errors on subsequent
-        // submissions in Next.js 16 with Server Actions
+        _state.actionArrayLengths.clear();
         if (!keepStateOptions.keepErrors) {
             _formState.errors = {};
         }
@@ -1961,8 +2354,10 @@ function createFormControl(props = {}) {
                 ? false
                 : keepStateOptions.keepDirty
                     ? _formState.isDirty
-                    : !!(keepStateOptions.keepDefaultValues &&
-                        !deepEqual(formValues, _defaultValues)),
+                    : keepStateOptions.keepValues
+                        ? _getDirty()
+                        : !!(keepStateOptions.keepDefaultValues &&
+                            !deepEqual(formValues, _defaultValues)),
             isSubmitted: keepStateOptions.keepIsSubmitted
                 ? _formState.isSubmitted
                 : false,
@@ -1970,16 +2365,22 @@ function createFormControl(props = {}) {
                 ? {}
                 : keepStateOptions.keepDirtyValues
                     ? keepStateOptions.keepDefaultValues && _formValues
-                        ? getDirtyFields(_defaultValues, _formValues)
+                        ? getDirtyFields(_defaultValues, _formValues, undefined, fieldRefs)
                         : _formState.dirtyFields
                     : keepStateOptions.keepDefaultValues && formValues
-                        ? getDirtyFields(_defaultValues, formValues)
+                        ? getDirtyFields(_defaultValues, formValues, undefined, fieldRefs)
                         : keepStateOptions.keepDirty
                             ? _formState.dirtyFields
-                            : {},
+                            : keepStateOptions.keepValues
+                                ? getDirtyFields(_defaultValues, _formValues, undefined, fieldRefs)
+                                : {},
             touchedFields: keepStateOptions.keepTouched
                 ? _formState.touchedFields
                 : {},
+            ...(!keepStateOptions.keepIsValidating &&
+                (_formState.isValidating || !isEmptyObject(_formState.validatingFields))
+                ? { validatingFields: {}, isValidating: false }
+                : null),
             errors: keepStateOptions.keepErrors ? _formState.errors : {},
             isSubmitSuccessful: keepStateOptions.keepIsSubmitSuccessful
                 ? _formState.isSubmitSuccessful
@@ -1999,8 +2400,6 @@ function createFormControl(props = {}) {
                 ? fieldReference.refs[0]
                 : fieldReference.ref;
             if (fieldRef.focus) {
-                // Use setTimeout to ensure focus happens after any pending state updates
-                // This fixes the issue where setFocus doesn't work immediately after setError
                 setTimeout(() => {
                     fieldRef.focus();
                     options.shouldSelect &&
@@ -2011,11 +2410,18 @@ function createFormControl(props = {}) {
         }
     };
     const _setFormState = (updatedFormState) => {
+        // `name`, `type`, and `values` describe the event that produced this
+        // update, not the form's persisted state (they aren't part of
+        // `FormState`). Merging them in would leak a stale `name`/`type` from
+        // one event into a later, unrelated notification that doesn't specify
+        // its own.
+        const { name, type, values, ...formState } = updatedFormState;
         _formState = {
             ..._formState,
-            ...updatedFormState,
+            ...formState,
         };
     };
+    _subjects.state.subscribe({ next: _setFormState });
     const _resetDefaultValues = () => isFunction(_options.defaultValues) &&
         _options.defaultValues().then((values) => {
             reset(values, _options.resetOptions);
@@ -2023,6 +2429,21 @@ function createFormControl(props = {}) {
                 isLoading: false,
             });
         });
+    const resetDefaultValues = (values, options = {}) => {
+        _defaultValues = cloneObject(values);
+        if (!options.keepDirty) {
+            const newDirtyFields = getDirtyFields(_defaultValues, _formValues, undefined, _fields);
+            _formState.dirtyFields = newDirtyFields;
+            _formState.isDirty = !isEmptyObject(newDirtyFields);
+        }
+        if (!options.keepIsValid) {
+            _setValid();
+        }
+        _subjects.state.next({
+            ..._formState,
+            defaultValues: _defaultValues,
+        });
+    };
     const methods = {
         control: {
             register,
@@ -2079,6 +2500,10 @@ function createFormControl(props = {}) {
                     ..._options,
                     ...value,
                 };
+                _validationModeBeforeSubmit = getValidationModes(_options.mode);
+                _validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
+                shouldDisplayAllAssociatedErrors =
+                    _options.criteriaMode === VALIDATION_MODE.all;
             },
         },
         subscribe,
@@ -2089,8 +2514,10 @@ function createFormControl(props = {}) {
         setValue,
         setValues,
         getValues,
+        getErrors,
         reset,
         resetField,
+        resetDefaultValues,
         clearErrors,
         unregister,
         setError,