@vuehookform/core 0.3.0 → 0.4.0

package/dist/vuehookform.cjs

@@ -1,8 +1,21 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let vue = require("vue");
+var pathCache = /* @__PURE__ */ new Map();
+var PATH_CACHE_MAX_SIZE = 256;
+function getPathSegments(path) {
+	let segments = pathCache.get(path);
+	if (segments) return segments;
+	segments = path.split(".");
+	if (pathCache.size >= PATH_CACHE_MAX_SIZE) {
+		const firstKey = pathCache.keys().next().value;
+		if (firstKey !== void 0) pathCache.delete(firstKey);
+	}
+	pathCache.set(path, segments);
+	return segments;
+}
 function get(obj, path) {
 	if (!path || obj === null || obj === void 0) return obj;
-	const keys = path.split(".");
+	const keys = getPathSegments(path);
 	let result = obj;
 	for (const key of keys) {
 		if (result === null || result === void 0) return;
@@ -12,7 +25,7 @@ function get(obj, path) {
 }
 function set(obj, path, value) {
 	if (!path) return;
-	const keys = path.split(".");
+	const keys = getPathSegments(path).slice();
 	const UNSAFE_KEYS = [
 		"__proto__",
 		"constructor",
@@ -37,7 +50,7 @@ function set(obj, path, value) {
 }
 function unset(obj, path) {
 	if (!path) return;
-	const keys = path.split(".");
+	const keys = getPathSegments(path).slice();
 	const lastKey = keys.pop();
 	let current = obj;
 	for (const key of keys) {
@@ -53,11 +66,35 @@ function generateId() {
 	const random = Math.random().toString(36).substring(2, 11);
 	return `field_${Date.now()}_${idCounter++}_${random}`;
 }
-const __DEV__ = false;
+function deepClone(obj) {
+	if (obj === null || obj === void 0) return obj;
+	if (typeof obj !== "object") return obj;
+	if (obj instanceof Date) return new Date(obj.getTime());
+	if (Array.isArray(obj)) return obj.map((item) => deepClone(item));
+	const cloned = {};
+	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) cloned[key] = deepClone(obj[key]);
+	return cloned;
+}
+var proc = globalThis.process;
+const __DEV__ = proc?.env?.NODE_ENV !== "production";
 var warnedMessages = /* @__PURE__ */ new Set();
-function warnOnce(message, key) {}
-function warn(message) {}
+function warnOnce(message, key) {
+	if (!__DEV__) return;
+	const cacheKey = key ?? message;
+	if (warnedMessages.has(cacheKey)) return;
+	warnedMessages.add(cacheKey);
+	console.warn(`[vue-hook-form] ${message}`);
+}
+function warn(message) {
+	if (!__DEV__) return;
+	console.warn(`[vue-hook-form] ${message}`);
+}
 function validatePathSyntax(path) {
+	if (!__DEV__) return null;
+	if (!path || path.trim() === "") return "Path cannot be empty";
+	if (path.startsWith(".") || path.endsWith(".") || path.includes("..")) return `Invalid path "${path}": contains empty segments`;
+	if (path.includes("[")) return `Invalid path "${path}": use dot notation (e.g., "items.0") instead of bracket notation (e.g., "items[0]")`;
+	if (/\s/.test(path)) return `Invalid path "${path}": paths cannot contain whitespace`;
 	return null;
 }
 function traverseSchemaPath(schema, path) {
@@ -67,7 +104,7 @@ function traverseSchemaPath(schema, path) {
 		const segment = segments[i];
 		if (!segment) continue;
 		currentSchema = unwrapSchema(currentSchema);
-		if (isZodObject(currentSchema)) {
+		if (isZodObject$1(currentSchema)) {
 			const shape = currentSchema.shape;
 			if (segment in shape) {
 				const nextSchema = shape[segment];
@@ -82,7 +119,7 @@ function traverseSchemaPath(schema, path) {
 				segmentIndex: i
 			};
 		}
-		if (isZodArray(currentSchema) && /^\d+$/.test(segment)) {
+		if (isZodArray$1(currentSchema) && /^\d+$/.test(segment)) {
 			currentSchema = currentSchema.element;
 			continue;
 		}
@@ -94,32 +131,93 @@ function traverseSchemaPath(schema, path) {
 	return { schema: currentSchema };
 }
 function validatePathAgainstSchema(schema, path) {
-	return { valid: true };
+	if (!__DEV__) return { valid: true };
+	try {
+		const result = traverseSchemaPath(schema, path);
+		if ("error" in result) return {
+			valid: false,
+			reason: result.error,
+			availableFields: result.availableFields
+		};
+		return { valid: true };
+	} catch {
+		return { valid: true };
+	}
 }
 function isArrayFieldInSchema(schema, path) {
-	return null;
+	if (!__DEV__) return null;
+	try {
+		const result = traverseSchemaPath(schema, path);
+		if ("error" in result) return null;
+		return isZodArray$1(unwrapSchema(result.schema));
+	} catch {
+		return null;
+	}
 }
-function warnInvalidPath(fnName, path, reason) {}
-function warnPathNotInSchema(fnName, path, availableFields) {}
-function warnFieldsOnNonArray(path) {}
-function warnArrayOperationRejected(operation, path, reason, details) {}
-function warnArrayIndexOutOfBounds(operation, path, index, length) {}
-function getDefProp(schema, prop) {
+function warnInvalidPath(fnName, path, reason) {
+	if (!__DEV__) return;
+	let message = `${fnName}("${path}"): ${reason}`;
+	if (reason.includes("bracket notation")) {
+		const fixedPath = path.replace(/\[(\d+)\]/g, ".$1");
+		message += `\n  FIX: Use dot notation for array indices`;
+		message += `\n  EXAMPLE: ${fnName}("${fixedPath}")`;
+	} else if (reason.includes("empty")) {
+		message += `\n  FIX: Provide a non-empty field path`;
+		message += `\n  EXAMPLE: ${fnName}("email") or ${fnName}("user.address.city")`;
+	} else if (reason.includes("whitespace")) {
+		const fixedPath = path.replace(/\s/g, "");
+		message += `\n  FIX: Remove spaces from the field path`;
+		message += `\n  EXAMPLE: ${fnName}("${fixedPath}")`;
+	} else if (reason.includes("empty segments")) {
+		const fixedPath = path.replace(/\.{2,}/g, ".").replace(/^\./, "").replace(/\.$/, "");
+		message += `\n  FIX: Remove extra dots from the path`;
+		message += `\n  EXAMPLE: ${fnName}("${fixedPath}")`;
+	}
+	warnOnce(message, `invalid-path:${fnName}:${path}`);
+}
+function warnPathNotInSchema(fnName, path, availableFields) {
+	if (!__DEV__) return;
+	let message = `${fnName}("${path}"): Path does not exist in your Zod schema.`;
+	message += `\n  FIX: Check that the path matches your schema definition exactly (case-sensitive)`;
+	if (availableFields && availableFields.length > 0) {
+		const pathLower = path.toLowerCase();
+		const suggestions = availableFields.filter((f) => f.toLowerCase().includes(pathLower) || pathLower.includes(f.toLowerCase()));
+		if (suggestions.length > 0) message += `\n  DID YOU MEAN: ${suggestions.slice(0, 3).map((s) => `"${s}"`).join(", ")}`;
+		message += `\n  AVAILABLE: ${availableFields.slice(0, 8).join(", ")}${availableFields.length > 8 ? "..." : ""}`;
+	}
+	warnOnce(message, `path-not-in-schema:${fnName}:${path}`);
+}
+function warnFieldsOnNonArray(path) {
+	if (!__DEV__) return;
+	warnOnce(`fields("${path}"): Expected an array field, but this path does not point to an array in your schema. The fields() method is only for array fields. Use register() for non-array fields.`, `fields-non-array:${path}`);
+}
+function warnArrayOperationRejected(operation, path, reason, details) {
+	if (!__DEV__) return;
+	warn(`${operation}() on "${path}": ${{
+		maxLength: details ? `Would exceed maxLength (current: ${details.current}, max: ${details.limit})` : "Would exceed maxLength rule",
+		minLength: details ? `Would violate minLength (current: ${details.current}, min: ${details.limit})` : "Would violate minLength rule"
+	}[reason]}. Operation was silently ignored.`);
+}
+function warnArrayIndexOutOfBounds(operation, path, index, length) {
+	if (!__DEV__) return;
+	warn(`${operation}() on "${path}": Index ${index} is out of bounds (array length: ${length}). Operation was silently ignored.`);
+}
+function getDefProp$1(schema, prop) {
 	return schema.def[prop];
 }
 function getTypeName(schema) {
-	return getDefProp(schema, "typeName");
+	return getDefProp$1(schema, "typeName");
 }
-function isZodObject(schema) {
+function isZodObject$1(schema) {
 	return getTypeName(schema) === "ZodObject";
 }
-function isZodArray(schema) {
+function isZodArray$1(schema) {
 	return getTypeName(schema) === "ZodArray";
 }
 function unwrapSchema(schema) {
 	const typeName = getTypeName(schema);
-	const innerType = getDefProp(schema, "innerType");
-	const schemaType = getDefProp(schema, "schema");
+	const innerType = getDefProp$1(schema, "innerType");
+	const schemaType = getDefProp$1(schema, "schema");
 	if ((typeName === "ZodOptional" || typeName === "ZodNullable" || typeName === "ZodDefault") && innerType) return unwrapSchema(innerType);
 	if (typeName === "ZodEffects" && schemaType) return unwrapSchema(schemaType);
 	return schema;
@@ -152,7 +250,7 @@ function createFormContext(options) {
 	const submitCount = (0, vue.ref)(0);
 	const defaultValuesError = (0, vue.ref)(null);
 	const isSubmitSuccessful = (0, vue.ref)(false);
-	const validatingFields = (0, vue.shallowRef)({});
+	const validatingFields = (0, vue.shallowRef)(/* @__PURE__ */ new Set());
 	const externalErrors = (0, vue.shallowRef)({});
 	const errorDelayTimers = /* @__PURE__ */ new Map();
 	const pendingErrors = /* @__PURE__ */ new Map();
@@ -163,6 +261,10 @@ function createFormContext(options) {
 	const debounceTimers = /* @__PURE__ */ new Map();
 	const validationRequestIds = /* @__PURE__ */ new Map();
 	const resetGeneration = (0, vue.ref)(0);
+	const dirtyFieldCount = (0, vue.ref)(0);
+	const touchedFieldCount = (0, vue.ref)(0);
+	const validationCache = /* @__PURE__ */ new Map();
+	const schemaValidationTimers = /* @__PURE__ */ new Map();
 	const isDisabled = (0, vue.ref)(false);
 	if (options.disabled !== void 0) {
 		isDisabled.value = (0, vue.toValue)(options.disabled) ?? false;
@@ -220,24 +322,136 @@ function createFormContext(options) {
 		validationRequestIds,
 		resetGeneration,
 		isDisabled,
+		dirtyFieldCount,
+		touchedFieldCount,
+		validationCache,
+		schemaValidationTimers,
 		options
 	};
 }
+var uniqueIdCounter = 0;
+function hashValue(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	const type = typeof value;
+	if (type === "string") return `s:${value}`;
+	if (type === "number") return `n:${value}`;
+	if (type === "boolean") return `b:${value}`;
+	if (type === "object") try {
+		return `o:${JSON.stringify(value)}`;
+	} catch {
+		return `o:_${++uniqueIdCounter}`;
+	}
+	return `x:_${++uniqueIdCounter}`;
+}
+function getDefType(schema) {
+	return schema._def?.type;
+}
+function getDefProp(schema, prop) {
+	return schema._def?.[prop];
+}
+function isZodObject(schema) {
+	return getDefType(schema) === "object";
+}
+function isZodArray(schema) {
+	return getDefType(schema) === "array";
+}
+function hasChecks(schema) {
+	const checks = getDefProp(schema, "checks");
+	return Array.isArray(checks) && checks.length > 0;
+}
+function unwrapNonEffects(schema) {
+	const type = getDefType(schema);
+	const innerType = getDefProp(schema, "innerType");
+	if ((type === "optional" || type === "nullable" || type === "default") && innerType) return unwrapNonEffects(innerType);
+	return schema;
+}
+var analysisCache = /* @__PURE__ */ new WeakMap();
+function hasRootEffects(schema) {
+	return hasChecks(schema);
+}
+function extractSubSchema(schema, path) {
+	const segments = path.split(".");
+	let currentSchema = schema;
+	let hasEffects = false;
+	for (const segment of segments) {
+		if (!segment) continue;
+		if (hasChecks(currentSchema)) hasEffects = true;
+		const unwrapped = unwrapNonEffects(currentSchema);
+		if (hasChecks(unwrapped)) hasEffects = true;
+		if (isZodObject(unwrapped)) {
+			const shape = getDefProp(unwrapped, "shape");
+			if (!shape || !(segment in shape)) return null;
+			currentSchema = shape[segment];
+		} else if (isZodArray(unwrapped) && /^\d+$/.test(segment)) {
+			const element = getDefProp(unwrapped, "element");
+			if (!element) return null;
+			currentSchema = element;
+		} else return null;
+	}
+	const finalUnwrapped = unwrapNonEffects(currentSchema);
+	const finalChecks = getDefProp(finalUnwrapped, "checks");
+	if (finalChecks) {
+		for (const check of finalChecks) if (check && typeof check === "object" && "type" in check && check.type === "custom") {
+			hasEffects = true;
+			break;
+		}
+	}
+	return {
+		schema: finalUnwrapped,
+		hasEffects
+	};
+}
+function analyzeSchemaPath(schema, path) {
+	let cache = analysisCache.get(schema);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		analysisCache.set(schema, cache);
+	}
+	const cached = cache.get(path);
+	if (cached) return cached;
+	if (hasRootEffects(schema)) {
+		const result$1 = {
+			canPartialValidate: false,
+			reason: "root-checks"
+		};
+		cache.set(path, result$1);
+		return result$1;
+	}
+	const extracted = extractSubSchema(schema, path);
+	if (!extracted) {
+		const result$1 = {
+			canPartialValidate: false,
+			reason: "invalid-path"
+		};
+		cache.set(path, result$1);
+		return result$1;
+	}
+	if (extracted.hasEffects) {
+		const result$1 = {
+			canPartialValidate: false,
+			reason: "path-checks"
+		};
+		cache.set(path, result$1);
+		return result$1;
+	}
+	const result = {
+		canPartialValidate: true,
+		subSchema: extracted.schema
+	};
+	cache.set(path, result);
+	return result;
+}
 function clearFieldErrors$1(errors, fieldPath) {
 	const newErrors = { ...errors };
 	for (const key of Object.keys(newErrors)) if (key === fieldPath || key.startsWith(`${fieldPath}.`)) delete newErrors[key];
 	return newErrors;
 }
 function setValidating(ctx, fieldPath, isValidating) {
-	if (isValidating) ctx.validatingFields.value = {
-		...ctx.validatingFields.value,
-		[fieldPath]: true
-	};
-	else {
-		const newValidating = { ...ctx.validatingFields.value };
-		delete newValidating[fieldPath];
-		ctx.validatingFields.value = newValidating;
-	}
+	const newSet = new Set(ctx.validatingFields.value);
+	if (isValidating) newSet.add(fieldPath);
+	else newSet.delete(fieldPath);
+	ctx.validatingFields.value = newSet;
 }
 function groupErrorsByPath(issues) {
 	const grouped = /* @__PURE__ */ new Map();
@@ -279,6 +493,18 @@ function createValidation(ctx) {
 		if (!ctx.options.shouldUseNativeValidation) return;
 		for (const [path] of ctx.fieldRefs) applyNativeValidation(path, null);
 	}
+	function scheduleErrorsBatch(errors) {
+		if ((ctx.options.delayError || 0) <= 0) {
+			const newErrors = { ...ctx.errors.value };
+			for (const [fieldPath, error] of errors) {
+				set(newErrors, fieldPath, error);
+				applyNativeValidation(fieldPath, typeof error === "string" ? error : error.message);
+			}
+			ctx.errors.value = newErrors;
+			return;
+		}
+		for (const [fieldPath, error] of errors) scheduleError(fieldPath, error);
+	}
 	function scheduleError(fieldPath, error) {
 		const delayMs = ctx.options.delayError || 0;
 		const errorMessage = typeof error === "string" ? error : error.message;
@@ -320,42 +546,108 @@ function createValidation(ctx) {
 		ctx.errorDelayTimers.clear();
 		ctx.pendingErrors.clear();
 	}
+	async function validateFieldPartial(fieldPath, subSchema, valueHash, criteriaMode, generationAtStart) {
+		const fieldValue = get(ctx.formData, fieldPath);
+		setValidating(ctx, fieldPath, true);
+		try {
+			const result = await subSchema.safeParseAsync(fieldValue);
+			if (ctx.resetGeneration.value !== generationAtStart) return true;
+			if (result.success) {
+				ctx.errors.value = cancelError(fieldPath);
+				if (valueHash) ctx.validationCache.set(fieldPath, {
+					hash: valueHash,
+					isValid: true
+				});
+				return true;
+			}
+			const fieldErrors = result.error.issues.map((issue) => ({
+				...issue,
+				path: fieldPath.split(".").concat(issue.path.map(String))
+			}));
+			ctx.errors.value = cancelError(fieldPath);
+			const grouped = groupErrorsByPath(fieldErrors);
+			const errorBatch = [];
+			for (const [path, errors] of grouped) errorBatch.push([path, createFieldError(errors, criteriaMode)]);
+			scheduleErrorsBatch(errorBatch);
+			if (valueHash) ctx.validationCache.set(fieldPath, {
+				hash: valueHash,
+				isValid: false
+			});
+			return false;
+		} finally {
+			setValidating(ctx, fieldPath, false);
+		}
+	}
+	async function validateFieldFull(fieldPath, valueHash, criteriaMode, generationAtStart) {
+		setValidating(ctx, fieldPath, true);
+		try {
+			const result = await ctx.options.schema.safeParseAsync(ctx.formData);
+			if (ctx.resetGeneration.value !== generationAtStart) return true;
+			if (result.success) {
+				ctx.errors.value = cancelError(fieldPath);
+				if (valueHash) ctx.validationCache.set(fieldPath, {
+					hash: valueHash,
+					isValid: true
+				});
+				return true;
+			}
+			const fieldErrors = result.error.issues.filter((issue) => {
+				const path = issue.path.join(".");
+				return path === fieldPath || path.startsWith(`${fieldPath}.`);
+			});
+			if (fieldErrors.length === 0) {
+				ctx.errors.value = cancelError(fieldPath);
+				if (valueHash) ctx.validationCache.set(fieldPath, {
+					hash: valueHash,
+					isValid: true
+				});
+				return true;
+			}
+			ctx.errors.value = cancelError(fieldPath);
+			const grouped = groupErrorsByPath(fieldErrors);
+			const errorBatch = [];
+			for (const [path, errors] of grouped) errorBatch.push([path, createFieldError(errors, criteriaMode)]);
+			scheduleErrorsBatch(errorBatch);
+			if (valueHash) ctx.validationCache.set(fieldPath, {
+				hash: valueHash,
+				isValid: false
+			});
+			return false;
+		} finally {
+			setValidating(ctx, fieldPath, false);
+		}
+	}
 	async function validate(fieldPath) {
 		const generationAtStart = ctx.resetGeneration.value;
 		const criteriaMode = ctx.options.criteriaMode || "firstError";
-		const validatingKey = fieldPath || "_form";
+		let valueHash;
+		if (fieldPath) {
+			valueHash = hashValue(get(ctx.formData, fieldPath));
+			const cached = ctx.validationCache.get(fieldPath);
+			if (cached && cached.hash === valueHash) return cached.isValid;
+			const analysis = analyzeSchemaPath(ctx.options.schema, fieldPath);
+			if (analysis.canPartialValidate && analysis.subSchema) return validateFieldPartial(fieldPath, analysis.subSchema, valueHash, criteriaMode, generationAtStart);
+			return validateFieldFull(fieldPath, valueHash, criteriaMode, generationAtStart);
+		}
+		const validatingKey = "_form";
 		setValidating(ctx, validatingKey, true);
 		try {
 			const result = await ctx.options.schema.safeParseAsync(ctx.formData);
 			if (ctx.resetGeneration.value !== generationAtStart) return true;
 			if (result.success) {
-				if (fieldPath) ctx.errors.value = cancelError(fieldPath);
-				else {
-					clearAllPendingErrors();
-					ctx.errors.value = {};
-					clearAllNativeValidation();
-				}
+				clearAllPendingErrors();
+				ctx.errors.value = {};
+				clearAllNativeValidation();
+				ctx.validationCache.clear();
 				return true;
 			}
-			const zodErrors = result.error.issues;
-			if (fieldPath) {
-				const fieldErrors = zodErrors.filter((issue) => {
-					const path = issue.path.join(".");
-					return path === fieldPath || path.startsWith(`${fieldPath}.`);
-				});
-				if (fieldErrors.length === 0) {
-					ctx.errors.value = cancelError(fieldPath);
-					return true;
-				}
-				ctx.errors.value = cancelError(fieldPath);
-				const grouped$1 = groupErrorsByPath(fieldErrors);
-				for (const [path, errors] of grouped$1) scheduleError(path, createFieldError(errors, criteriaMode));
-				return false;
-			}
 			clearAllPendingErrors();
 			ctx.errors.value = {};
-			const grouped = groupErrorsByPath(zodErrors);
-			for (const [path, errors] of grouped) scheduleError(path, createFieldError(errors, criteriaMode));
+			const grouped = groupErrorsByPath(result.error.issues);
+			const errorBatch = [];
+			for (const [path, errors] of grouped) errorBatch.push([path, createFieldError(errors, criteriaMode)]);
+			scheduleErrorsBatch(errorBatch);
+			ctx.validationCache.clear();
 			return false;
 		} finally {
 			setValidating(ctx, validatingKey, false);
@@ -366,9 +658,57 @@ function createValidation(ctx) {
 		clearAllPendingErrors
 	};
 }
+function markFieldDirty(dirtyFields, dirtyFieldCount, fieldName) {
+	if (dirtyFields.value[fieldName]) return;
+	dirtyFields.value = {
+		...dirtyFields.value,
+		[fieldName]: true
+	};
+	dirtyFieldCount.value++;
+}
+function markFieldTouched(touchedFields, touchedFieldCount, fieldName) {
+	if (touchedFields.value[fieldName]) return;
+	touchedFields.value = {
+		...touchedFields.value,
+		[fieldName]: true
+	};
+	touchedFieldCount.value++;
+}
+function clearFieldDirty(dirtyFields, dirtyFieldCount, fieldName) {
+	if (!(fieldName in dirtyFields.value)) return;
+	const newDirty = { ...dirtyFields.value };
+	delete newDirty[fieldName];
+	dirtyFields.value = newDirty;
+	dirtyFieldCount.value--;
+}
+function clearFieldTouched(touchedFields, touchedFieldCount, fieldName) {
+	if (!(fieldName in touchedFields.value)) return;
+	const newTouched = { ...touchedFields.value };
+	delete newTouched[fieldName];
+	touchedFields.value = newTouched;
+	touchedFieldCount.value--;
+}
+function clearFieldErrors(errors, fieldName) {
+	const currentErrors = errors.value;
+	const keys = Object.keys(currentErrors);
+	if (keys.length === 0) return;
+	const prefix = `${fieldName}.`;
+	const keysToDelete = [];
+	for (const key of keys) if (key === fieldName || key.startsWith(prefix)) keysToDelete.push(key);
+	if (keysToDelete.length === 0) return;
+	const newErrors = { ...currentErrors };
+	for (const key of keysToDelete) delete newErrors[key];
+	errors.value = newErrors;
+}
 var validationRequestCounter = 0;
 function createFieldRegistration(ctx, validate) {
 	function register(name, registerOptions) {
+		if (__DEV__) {
+			const syntaxError = validatePathSyntax(name);
+			if (syntaxError) warnInvalidPath("register", name, syntaxError);
+			const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
+			if (!schemaResult.valid) warnPathNotInSchema("register", name, schemaResult.availableFields);
+		}
 		let fieldRef = ctx.fieldRefs.get(name);
 		if (!fieldRef) {
 			fieldRef = (0, vue.ref)(null);
@@ -401,16 +741,30 @@ function createFieldRegistration(ctx, validate) {
 				const target = e.target;
 				const value = target.type === "checkbox" ? target.checked : target.value;
 				set(ctx.formData, name, value);
-				ctx.dirtyFields.value = {
-					...ctx.dirtyFields.value,
-					[name]: true
-				};
+				markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
+				const fieldOpts = ctx.fieldOptions.get(name);
 				if (ctx.options.mode === "onChange" || ctx.options.mode === "onTouched" && ctx.touchedFields.value[name] || ctx.touchedFields.value[name] && ctx.options.reValidateMode === "onChange") {
-					await validate(name);
-					const fieldOpts$1 = ctx.fieldOptions.get(name);
-					if (fieldOpts$1?.deps && fieldOpts$1.deps.length > 0) for (const depField of fieldOpts$1.deps) validate(depField);
+					const validationDebounceMs = ctx.options.validationDebounce || 0;
+					if (validationDebounceMs > 0) {
+						const existingTimer = ctx.schemaValidationTimers.get(name);
+						if (existingTimer) clearTimeout(existingTimer);
+						const timer = setTimeout(async () => {
+							ctx.schemaValidationTimers.delete(name);
+							await validate(name);
+							if (fieldOpts?.deps && fieldOpts.deps.length > 0) {
+								const uniqueDeps = [...new Set(fieldOpts.deps)];
+								await Promise.all(uniqueDeps.map((depField) => validate(depField)));
+							}
+						}, validationDebounceMs);
+						ctx.schemaValidationTimers.set(name, timer);
+					} else {
+						await validate(name);
+						if (fieldOpts?.deps && fieldOpts.deps.length > 0) {
+							const uniqueDeps = [...new Set(fieldOpts.deps)];
+							await Promise.all(uniqueDeps.map((depField) => validate(depField)));
+						}
+					}
 				}
-				const fieldOpts = ctx.fieldOptions.get(name);
 				if (fieldOpts?.validate && !fieldOpts.disabled) {
 					const requestId = ++validationRequestCounter;
 					ctx.validationRequestIds.set(name, requestId);
@@ -419,23 +773,24 @@ function createFieldRegistration(ctx, validate) {
 					if (debounceMs > 0) {
 						const existingTimer = ctx.debounceTimers.get(name);
 						if (existingTimer) clearTimeout(existingTimer);
-						const timer = setTimeout(() => {
+						const timer = setTimeout(async () => {
 							ctx.debounceTimers.delete(name);
-							runCustomValidation(name, value, requestId, resetGenAtStart);
+							await runCustomValidation(name, value, requestId, resetGenAtStart);
+							ctx.validationRequestIds.delete(name);
 						}, debounceMs);
 						ctx.debounceTimers.set(name, timer);
 					} else await runCustomValidation(name, value, requestId, resetGenAtStart);
 				}
 			};
 			const onBlur = async (_e) => {
-				ctx.touchedFields.value = {
-					...ctx.touchedFields.value,
-					[name]: true
-				};
+				markFieldTouched(ctx.touchedFields, ctx.touchedFieldCount, name);
 				if (ctx.options.mode === "onBlur" || ctx.options.mode === "onTouched" || ctx.submitCount.value > 0 && ctx.options.reValidateMode === "onBlur") {
 					await validate(name);
 					const fieldOpts = ctx.fieldOptions.get(name);
-					if (fieldOpts?.deps && fieldOpts.deps.length > 0) for (const depField of fieldOpts.deps) validate(depField);
+					if (fieldOpts?.deps && fieldOpts.deps.length > 0) {
+						const uniqueDeps = [...new Set(fieldOpts.deps)];
+						await Promise.all(uniqueDeps.map((depField) => validate(depField)));
+					}
 				}
 			};
 			const refCallback = (el) => {
@@ -457,18 +812,17 @@ function createFieldRegistration(ctx, validate) {
 						clearTimeout(timer);
 						ctx.debounceTimers.delete(name);
 					}
+					const schemaTimer = ctx.schemaValidationTimers.get(name);
+					if (schemaTimer) {
+						clearTimeout(schemaTimer);
+						ctx.schemaValidationTimers.delete(name);
+					}
 					ctx.validationRequestIds.delete(name);
 					if (opts?.shouldUnregister ?? ctx.options.shouldUnregister ?? false) {
 						unset(ctx.formData, name);
-						const newErrors = { ...ctx.errors.value };
-						delete newErrors[name];
-						ctx.errors.value = newErrors;
-						const newTouched = { ...ctx.touchedFields.value };
-						delete newTouched[name];
-						ctx.touchedFields.value = newTouched;
-						const newDirty = { ...ctx.dirtyFields.value };
-						delete newDirty[name];
-						ctx.dirtyFields.value = newDirty;
+						clearFieldErrors(ctx.errors, name);
+						clearFieldTouched(ctx.touchedFields, ctx.touchedFieldCount, name);
+						clearFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 						ctx.fieldRefs.delete(name);
 						ctx.fieldOptions.delete(name);
 						ctx.fieldHandlers.delete(name);
@@ -492,10 +846,7 @@ function createFieldRegistration(ctx, validate) {
 				get: () => get(ctx.formData, name),
 				set: (val) => {
 					set(ctx.formData, name, val);
-					ctx.dirtyFields.value = {
-						...ctx.dirtyFields.value,
-						[name]: true
-					};
+					markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 				}
 			}) }
 		};
@@ -503,21 +854,9 @@ function createFieldRegistration(ctx, validate) {
 	function unregister(name, options) {
 		const opts = options || {};
 		if (!opts.keepValue) unset(ctx.formData, name);
-		if (!opts.keepError) {
-			const newErrors = { ...ctx.errors.value };
-			delete newErrors[name];
-			ctx.errors.value = newErrors;
-		}
-		if (!opts.keepTouched) {
-			const newTouched = { ...ctx.touchedFields.value };
-			delete newTouched[name];
-			ctx.touchedFields.value = newTouched;
-		}
-		if (!opts.keepDirty) {
-			const newDirty = { ...ctx.dirtyFields.value };
-			delete newDirty[name];
-			ctx.dirtyFields.value = newDirty;
-		}
+		if (!opts.keepError) clearFieldErrors(ctx.errors, name);
+		if (!opts.keepTouched) clearFieldTouched(ctx.touchedFields, ctx.touchedFieldCount, name);
+		if (!opts.keepDirty) clearFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 		ctx.fieldRefs.delete(name);
 		ctx.fieldOptions.delete(name);
 		ctx.fieldHandlers.delete(name);
@@ -526,6 +865,11 @@ function createFieldRegistration(ctx, validate) {
 			clearTimeout(timer);
 			ctx.debounceTimers.delete(name);
 		}
+		const schemaTimer = ctx.schemaValidationTimers.get(name);
+		if (schemaTimer) {
+			clearTimeout(schemaTimer);
+			ctx.schemaValidationTimers.delete(name);
+		}
 		ctx.validationRequestIds.delete(name);
 	}
 	return {
@@ -535,6 +879,13 @@ function createFieldRegistration(ctx, validate) {
 }
 function createFieldArrayManager(ctx, validate, setFocus) {
 	function fields(name, options) {
+		if (__DEV__) {
+			const syntaxError = validatePathSyntax(name);
+			if (syntaxError) warnInvalidPath("fields", name, syntaxError);
+			const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
+			if (!schemaResult.valid) warnPathNotInSchema("fields", name, schemaResult.availableFields);
+			if (isArrayFieldInSchema(ctx.options.schema, name) === false) warnFieldsOnNonArray(name);
+		}
 		let fieldArray = ctx.fieldArrays.get(name);
 		if (!fieldArray) {
 			const existingValues = get(ctx.formData, name) || [];
@@ -555,6 +906,35 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				indexCache.set(item.key, idx);
 			});
 		};
+		const appendToCache = (startIndex) => {
+			const items = fa.items.value;
+			for (let i = startIndex; i < items.length; i++) {
+				const item = items[i];
+				if (item) indexCache.set(item.key, i);
+			}
+		};
+		const updateCacheAfterInsert = (insertIndex, _insertCount) => {
+			const items = fa.items.value;
+			for (let i = insertIndex; i < items.length; i++) {
+				const item = items[i];
+				if (item) indexCache.set(item.key, i);
+			}
+		};
+		const swapInCache = (indexA, indexB) => {
+			const items = fa.items.value;
+			const itemA = items[indexA];
+			const itemB = items[indexB];
+			if (itemA) indexCache.set(itemA.key, indexA);
+			if (itemB) indexCache.set(itemB.key, indexB);
+		};
+		const updateCacheAfterRemove = (removedKey, startIndex) => {
+			indexCache.delete(removedKey);
+			const items = fa.items.value;
+			for (let i = startIndex; i < items.length; i++) {
+				const item = items[i];
+				if (item) indexCache.set(item.key, i);
+			}
+		};
 		const createItem = (key) => ({
 			key,
 			get index() {
@@ -586,16 +966,19 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			const currentValues = get(ctx.formData, name) || [];
 			const insertIndex = currentValues.length;
 			const rules = fa.rules;
-			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) return false;
+			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) {
+				if (__DEV__) warnArrayOperationRejected("append", name, "maxLength", {
+					current: currentValues.length,
+					limit: rules.maxLength.value
+				});
+				return false;
+			}
 			const newValues = [...currentValues, ...values];
 			set(ctx.formData, name, newValues);
 			const newItems = values.map(() => createItem(generateId()));
 			fa.items.value = [...fa.items.value, ...newItems];
-			rebuildIndexCache();
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			appendToCache(insertIndex);
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			handleFocus(insertIndex, values.length, focusOptions);
 			return true;
@@ -605,47 +988,56 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			if (values.length === 0) return true;
 			const currentValues = get(ctx.formData, name) || [];
 			const rules = fa.rules;
-			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) return false;
+			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) {
+				if (__DEV__) warnArrayOperationRejected("prepend", name, "maxLength", {
+					current: currentValues.length,
+					limit: rules.maxLength.value
+				});
+				return false;
+			}
 			const newValues = [...values, ...currentValues];
 			set(ctx.formData, name, newValues);
 			const newItems = values.map(() => createItem(generateId()));
 			fa.items.value = [...newItems, ...fa.items.value];
-			rebuildIndexCache();
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			updateCacheAfterInsert(0, values.length);
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			handleFocus(0, values.length, focusOptions);
 			return true;
 		};
 		const update = (index, value) => {
 			const currentValues = get(ctx.formData, name) || [];
-			if (index < 0 || index >= currentValues.length) return false;
+			if (index < 0 || index >= currentValues.length) {
+				if (__DEV__) warnArrayIndexOutOfBounds("update", name, index, currentValues.length);
+				return false;
+			}
 			const newValues = [...currentValues];
 			newValues[index] = value;
 			set(ctx.formData, name, newValues);
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			return true;
 		};
 		const removeAt = (index) => {
 			const currentValues = get(ctx.formData, name) || [];
-			if (index < 0 || index >= currentValues.length) return false;
+			if (index < 0 || index >= currentValues.length) {
+				if (__DEV__) warnArrayIndexOutOfBounds("remove", name, index, currentValues.length);
+				return false;
+			}
 			const rules = fa.rules;
-			if (rules?.minLength && currentValues.length - 1 < rules.minLength.value) return false;
+			if (rules?.minLength && currentValues.length - 1 < rules.minLength.value) {
+				if (__DEV__) warnArrayOperationRejected("remove", name, "minLength", {
+					current: currentValues.length,
+					limit: rules.minLength.value
+				});
+				return false;
+			}
 			const newValues = currentValues.filter((_, i) => i !== index);
 			set(ctx.formData, name, newValues);
 			const keyToRemove = fa.items.value[index]?.key;
 			fa.items.value = fa.items.value.filter((item) => item.key !== keyToRemove);
-			rebuildIndexCache();
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			if (keyToRemove) updateCacheAfterRemove(keyToRemove, index);
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			return true;
 		};
@@ -654,7 +1046,13 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			if (values.length === 0) return true;
 			const currentValues = get(ctx.formData, name) || [];
 			const rules = fa.rules;
-			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) return false;
+			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) {
+				if (__DEV__) warnArrayOperationRejected("insert", name, "maxLength", {
+					current: currentValues.length,
+					limit: rules.maxLength.value
+				});
+				return false;
+			}
 			const clampedIndex = Math.max(0, Math.min(index, currentValues.length));
 			const newValues = [
 				...currentValues.slice(0, clampedIndex),
@@ -668,18 +1066,18 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				...newItems,
 				...fa.items.value.slice(clampedIndex)
 			];
-			rebuildIndexCache();
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			updateCacheAfterInsert(clampedIndex, values.length);
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			handleFocus(clampedIndex, values.length, focusOptions);
 			return true;
 		};
 		const swap = (indexA, indexB) => {
 			const currentValues = get(ctx.formData, name) || [];
-			if (indexA < 0 || indexB < 0 || indexA >= currentValues.length || indexB >= currentValues.length) return false;
+			if (indexA < 0 || indexB < 0 || indexA >= currentValues.length || indexB >= currentValues.length) {
+				if (__DEV__) warnArrayIndexOutOfBounds("swap", name, indexA < 0 || indexA >= currentValues.length ? indexA : indexB, currentValues.length);
+				return false;
+			}
 			const newValues = [...currentValues];
 			[newValues[indexA], newValues[indexB]] = [newValues[indexB], newValues[indexA]];
 			set(ctx.formData, name, newValues);
@@ -690,18 +1088,18 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				newItems[indexA] = itemB;
 				newItems[indexB] = itemA;
 				fa.items.value = newItems;
-				rebuildIndexCache();
+				swapInCache(indexA, indexB);
 			}
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			return true;
 		};
 		const move = (from, to) => {
 			const currentValues = get(ctx.formData, name) || [];
-			if (from < 0 || from >= currentValues.length || to < 0) return false;
+			if (from < 0 || from >= currentValues.length || to < 0) {
+				if (__DEV__) warnArrayIndexOutOfBounds("move", name, from < 0 || from >= currentValues.length ? from : to, currentValues.length);
+				return false;
+			}
 			const newValues = [...currentValues];
 			const [removed] = newValues.splice(from, 1);
 			if (removed !== void 0) {
@@ -715,12 +1113,15 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 				const clampedTo = Math.min(to, newItems.length);
 				newItems.splice(clampedTo, 0, removedItem);
 				fa.items.value = newItems;
-				rebuildIndexCache();
+				const minIdx = Math.min(from, clampedTo);
+				const maxIdx = Math.max(from, clampedTo);
+				const items = fa.items.value;
+				for (let i = minIdx; i <= maxIdx; i++) {
+					const item = items[i];
+					if (item) indexCache.set(item.key, i);
+				}
 			}
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			return true;
 		};
@@ -729,23 +1130,23 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			set(ctx.formData, name, newValues);
 			fa.items.value = newValues.map(() => createItem(generateId()));
 			rebuildIndexCache();
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			return true;
 		};
 		const removeAll = () => {
 			const rules = fa.rules;
-			if (rules?.minLength && rules.minLength.value > 0) return false;
+			if (rules?.minLength && rules.minLength.value > 0) {
+				if (__DEV__) warnArrayOperationRejected("removeAll", name, "minLength", {
+					current: fa.items.value.length,
+					limit: rules.minLength.value
+				});
+				return false;
+			}
 			set(ctx.formData, name, []);
 			fa.items.value = [];
-			rebuildIndexCache();
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			indexCache.clear();
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			return true;
 		};
@@ -755,17 +1156,24 @@ function createFieldArrayManager(ctx, validate, setFocus) {
 			if (validIndices.length === 0) return true;
 			const rules = fa.rules;
 			const remainingCount = currentValues.length - validIndices.length;
-			if (rules?.minLength && remainingCount < rules.minLength.value) return false;
+			if (rules?.minLength && remainingCount < rules.minLength.value) {
+				if (__DEV__) warnArrayOperationRejected("removeMany", name, "minLength", {
+					current: currentValues.length,
+					limit: rules.minLength.value
+				});
+				return false;
+			}
 			const sortedIndices = [...new Set(validIndices)].sort((a, b) => b - a);
 			const indicesToRemove = new Set(sortedIndices);
+			const keysToRemove = fa.items.value.filter((_, i) => indicesToRemove.has(i)).map((item) => item.key);
 			const newValues = currentValues.filter((_, i) => !indicesToRemove.has(i));
 			set(ctx.formData, name, newValues);
 			fa.items.value = fa.items.value.filter((_, i) => !indicesToRemove.has(i));
-			rebuildIndexCache();
-			ctx.dirtyFields.value = {
-				...ctx.dirtyFields.value,
-				[name]: true
-			};
+			for (const key of keysToRemove) indexCache.delete(key);
+			fa.items.value.forEach((item, idx) => {
+				indexCache.set(item.key, idx);
+			});
+			markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
 			if (ctx.options.mode === "onChange") validate(name);
 			return true;
 		};
@@ -797,38 +1205,19 @@ function updateDomElement(el, value) {
 	if (el.type === "checkbox") el.checked = value;
 	else el.value = value;
 }
-function markFieldDirty(dirtyFields, fieldName) {
-	dirtyFields.value = {
-		...dirtyFields.value,
-		[fieldName]: true
-	};
-}
-function markFieldTouched(touchedFields, fieldName) {
-	touchedFields.value = {
-		...touchedFields.value,
-		[fieldName]: true
-	};
-}
-function clearFieldDirty(dirtyFields, fieldName) {
-	const newDirty = { ...dirtyFields.value };
-	delete newDirty[fieldName];
-	dirtyFields.value = newDirty;
-}
-function clearFieldTouched(touchedFields, fieldName) {
-	const newTouched = { ...touchedFields.value };
-	delete newTouched[fieldName];
-	touchedFields.value = newTouched;
-}
-function clearFieldErrors(errors, fieldName) {
-	const newErrors = { ...errors.value };
-	for (const key of Object.keys(newErrors)) if (key === fieldName || key.startsWith(`${fieldName}.`)) delete newErrors[key];
-	errors.value = newErrors;
-}
 function useForm(options) {
 	const ctx = createFormContext(options);
 	const { validate, clearAllPendingErrors } = createValidation(ctx);
 	const { register, unregister } = createFieldRegistration(ctx, validate);
 	function setFocus(name, focusOptions) {
+		if (__DEV__) {
+			const syntaxError = validatePathSyntax(name);
+			if (syntaxError) warnInvalidPath("setFocus", name, syntaxError);
+			else {
+				const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
+				if (!schemaResult.valid) warnPathNotInSchema("setFocus", name, schemaResult.availableFields);
+			}
+		}
 		const fieldRef = ctx.fieldRefs.get(name);
 		if (!fieldRef?.value) return;
 		const el = fieldRef.value;
@@ -839,32 +1228,84 @@ function useForm(options) {
 	}
 	const setFocusWrapper = (name) => setFocus(name);
 	const { fields } = createFieldArrayManager(ctx, validate, setFocusWrapper);
+	let lastSyncTime = 0;
+	const SYNC_DEBOUNCE_MS = 16;
+	function syncWithDebounce() {
+		const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+		if (now - lastSyncTime < SYNC_DEBOUNCE_MS) return;
+		syncUncontrolledInputs(ctx.fieldRefs, ctx.fieldOptions, ctx.formData);
+		lastSyncTime = now;
+	}
+	let lastErrors = ctx.errors.value;
+	let lastExternalErrors = ctx.externalErrors.value;
+	let cachedMergedErrors = null;
 	function getMergedErrors() {
-		return {
+		if (cachedMergedErrors !== null && lastErrors === ctx.errors.value && lastExternalErrors === ctx.externalErrors.value) return cachedMergedErrors;
+		lastErrors = ctx.errors.value;
+		lastExternalErrors = ctx.externalErrors.value;
+		cachedMergedErrors = {
 			...ctx.errors.value,
 			...ctx.externalErrors.value
 		};
+		return cachedMergedErrors;
 	}
-	const formState = (0, vue.computed)(() => {
-		const mergedErrors = getMergedErrors();
-		return {
-			errors: mergedErrors,
-			isDirty: Object.keys(ctx.dirtyFields.value).some((k) => ctx.dirtyFields.value[k]),
-			dirtyFields: ctx.dirtyFields.value,
-			isValid: (ctx.submitCount.value > 0 || Object.keys(ctx.touchedFields.value).length > 0) && Object.keys(mergedErrors).length === 0,
-			isSubmitting: ctx.isSubmitting.value,
-			isLoading: ctx.isLoading.value,
-			isReady: !ctx.isLoading.value,
-			isValidating: Object.keys(ctx.validatingFields.value).some((k) => ctx.validatingFields.value[k]),
-			validatingFields: ctx.validatingFields.value,
-			touchedFields: ctx.touchedFields.value,
-			submitCount: ctx.submitCount.value,
-			defaultValuesError: ctx.defaultValuesError.value,
-			isSubmitted: ctx.submitCount.value > 0,
-			isSubmitSuccessful: ctx.isSubmitSuccessful.value,
-			disabled: ctx.isDisabled.value
-		};
+	const isDirtyComputed = (0, vue.computed)(() => ctx.dirtyFieldCount.value > 0);
+	const errorsComputed = (0, vue.computed)(() => getMergedErrors());
+	const isValidComputed = (0, vue.computed)(() => {
+		if (!(ctx.submitCount.value > 0 || ctx.touchedFieldCount.value > 0)) return false;
+		return Object.keys(errorsComputed.value).length === 0;
+	});
+	const isReadyComputed = (0, vue.computed)(() => !ctx.isLoading.value);
+	const isValidatingComputed = (0, vue.computed)(() => ctx.validatingFields.value.size > 0);
+	const isSubmittedComputed = (0, vue.computed)(() => ctx.submitCount.value > 0);
+	const formStateInternal = (0, vue.reactive)({
+		get errors() {
+			return errorsComputed.value;
+		},
+		get isDirty() {
+			return isDirtyComputed.value;
+		},
+		get dirtyFields() {
+			return ctx.dirtyFields.value;
+		},
+		get isValid() {
+			return isValidComputed.value;
+		},
+		get isSubmitting() {
+			return ctx.isSubmitting.value;
+		},
+		get isLoading() {
+			return ctx.isLoading.value;
+		},
+		get isReady() {
+			return isReadyComputed.value;
+		},
+		get isValidating() {
+			return isValidatingComputed.value;
+		},
+		get validatingFields() {
+			return ctx.validatingFields.value;
+		},
+		get touchedFields() {
+			return ctx.touchedFields.value;
+		},
+		get submitCount() {
+			return ctx.submitCount.value;
+		},
+		get defaultValuesError() {
+			return ctx.defaultValuesError.value;
+		},
+		get isSubmitted() {
+			return isSubmittedComputed.value;
+		},
+		get isSubmitSuccessful() {
+			return ctx.isSubmitSuccessful.value;
+		},
+		get disabled() {
+			return ctx.isDisabled.value;
+		}
 	});
+	const formState = (0, vue.computed)(() => formStateInternal);
 	function handleSubmit(onValid, onInvalid) {
 		return async (e) => {
 			e.preventDefault();
@@ -874,7 +1315,7 @@ function useForm(options) {
 			ctx.submitCount.value++;
 			ctx.isSubmitSuccessful.value = false;
 			try {
-				syncUncontrolledInputs(ctx.fieldRefs, ctx.fieldOptions, ctx.formData);
+				syncWithDebounce();
 				if (await validate()) {
 					await onValid(ctx.formData);
 					ctx.isSubmitSuccessful.value = true;
@@ -891,9 +1332,17 @@ function useForm(options) {
 		};
 	}
 	function setValue(name, value, setValueOptions) {
+		if (__DEV__) {
+			const syntaxError = validatePathSyntax(name);
+			if (syntaxError) warnInvalidPath("setValue", name, syntaxError);
+			else {
+				const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
+				if (!schemaResult.valid) warnPathNotInSchema("setValue", name, schemaResult.availableFields);
+			}
+		}
 		set(ctx.formData, name, value);
-		if (setValueOptions?.shouldDirty !== false) markFieldDirty(ctx.dirtyFields, name);
-		if (setValueOptions?.shouldTouch) markFieldTouched(ctx.touchedFields, name);
+		if (setValueOptions?.shouldDirty !== false) markFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
+		if (setValueOptions?.shouldTouch) markFieldTouched(ctx.touchedFields, ctx.touchedFieldCount, name);
 		if (!ctx.fieldOptions.get(name)?.controlled) {
 			const fieldRef = ctx.fieldRefs.get(name);
 			if (fieldRef?.value) updateDomElement(fieldRef.value, value);
@@ -904,15 +1353,23 @@ function useForm(options) {
 		const opts = resetOptions || {};
 		ctx.resetGeneration.value++;
 		clearAllPendingErrors();
-		ctx.validatingFields.value = {};
+		ctx.validatingFields.value = /* @__PURE__ */ new Set();
+		ctx.validationCache.clear();
+		for (const timer of ctx.schemaValidationTimers.values()) clearTimeout(timer);
+		ctx.schemaValidationTimers.clear();
 		if (!opts.keepDefaultValues && values) Object.assign(ctx.defaultValues, values);
 		Object.keys(ctx.formData).forEach((key) => delete ctx.formData[key]);
-		const sourceValues = values || ctx.defaultValues;
-		const newValues = JSON.parse(JSON.stringify(sourceValues));
+		const newValues = deepClone(values || ctx.defaultValues);
 		Object.assign(ctx.formData, newValues);
 		if (!opts.keepErrors) ctx.errors.value = {};
-		if (!opts.keepTouched) ctx.touchedFields.value = {};
-		if (!opts.keepDirty) ctx.dirtyFields.value = {};
+		if (!opts.keepTouched) {
+			ctx.touchedFields.value = {};
+			ctx.touchedFieldCount.value = 0;
+		}
+		if (!opts.keepDirty) {
+			ctx.dirtyFields.value = {};
+			ctx.dirtyFieldCount.value = 0;
+		}
 		if (!opts.keepSubmitCount) ctx.submitCount.value = 0;
 		if (!opts.keepIsSubmitting) ctx.isSubmitting.value = false;
 		if (!opts.keepIsSubmitSuccessful) ctx.isSubmitSuccessful.value = false;
@@ -927,6 +1384,14 @@ function useForm(options) {
 		}
 	}
 	function resetField(name, resetFieldOptions) {
+		if (__DEV__) {
+			const syntaxError = validatePathSyntax(name);
+			if (syntaxError) warnInvalidPath("resetField", name, syntaxError);
+			else {
+				const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
+				if (!schemaResult.valid) warnPathNotInSchema("resetField", name, schemaResult.availableFields);
+			}
+		}
 		const opts = resetFieldOptions || {};
 		ctx.resetGeneration.value++;
 		const errorTimer = ctx.errorDelayTimers.get(name);
@@ -938,17 +1403,28 @@ function useForm(options) {
 		let defaultValue = opts.defaultValue;
 		if (defaultValue === void 0) defaultValue = get(ctx.defaultValues, name);
 		else set(ctx.defaultValues, name, defaultValue);
-		const clonedValue = defaultValue !== void 0 ? JSON.parse(JSON.stringify(defaultValue)) : void 0;
+		const clonedValue = defaultValue !== void 0 ? deepClone(defaultValue) : void 0;
 		set(ctx.formData, name, clonedValue);
 		if (!opts.keepError) clearFieldErrors(ctx.errors, name);
-		if (!opts.keepDirty) clearFieldDirty(ctx.dirtyFields, name);
-		if (!opts.keepTouched) clearFieldTouched(ctx.touchedFields, name);
+		if (!opts.keepDirty) clearFieldDirty(ctx.dirtyFields, ctx.dirtyFieldCount, name);
+		if (!opts.keepTouched) clearFieldTouched(ctx.touchedFields, ctx.touchedFieldCount, name);
 		if (!ctx.fieldOptions.get(name)?.controlled) {
 			const fieldRef = ctx.fieldRefs.get(name);
 			if (fieldRef?.value) updateDomElement(fieldRef.value, clonedValue ?? (fieldRef.value.type === "checkbox" ? false : ""));
 		}
 	}
 	function watch$1(name) {
+		if (__DEV__ && name) {
+			const names = Array.isArray(name) ? name : [name];
+			for (const n of names) {
+				const syntaxError = validatePathSyntax(n);
+				if (syntaxError) warnInvalidPath("watch", n, syntaxError);
+				else {
+					const schemaResult = validatePathAgainstSchema(ctx.options.schema, n);
+					if (!schemaResult.valid) warnPathNotInSchema("watch", n, schemaResult.availableFields);
+				}
+			}
+		}
 		return (0, vue.computed)(() => {
 			if (!name) return ctx.formData;
 			if (Array.isArray(name)) {
@@ -960,6 +1436,18 @@ function useForm(options) {
 		});
 	}
 	function clearErrors(name) {
+		if (__DEV__ && name && !String(name).startsWith("root")) {
+			const names = Array.isArray(name) ? name : [name];
+			for (const n of names) {
+				if (String(n).startsWith("root")) continue;
+				const syntaxError = validatePathSyntax(n);
+				if (syntaxError) warnInvalidPath("clearErrors", n, syntaxError);
+				else {
+					const schemaResult = validatePathAgainstSchema(ctx.options.schema, n);
+					if (!schemaResult.valid) warnPathNotInSchema("clearErrors", n, schemaResult.availableFields);
+				}
+			}
+		}
 		if (name === void 0) {
 			ctx.errors.value = {};
 			return;
@@ -998,7 +1486,18 @@ function useForm(options) {
 		return get(mergedErrors, fieldPath);
 	}
 	function getValues(nameOrNames) {
-		syncUncontrolledInputs(ctx.fieldRefs, ctx.fieldOptions, ctx.formData);
+		if (__DEV__ && nameOrNames) {
+			const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames];
+			for (const n of names) {
+				const syntaxError = validatePathSyntax(n);
+				if (syntaxError) warnInvalidPath("getValues", n, syntaxError);
+				else {
+					const schemaResult = validatePathAgainstSchema(ctx.options.schema, n);
+					if (!schemaResult.valid) warnPathNotInSchema("getValues", n, schemaResult.availableFields);
+				}
+			}
+		}
+		syncWithDebounce();
 		if (nameOrNames === void 0) return { ...ctx.formData };
 		if (Array.isArray(nameOrNames)) {
 			const result = {};
@@ -1008,6 +1507,14 @@ function useForm(options) {
 		return get(ctx.formData, nameOrNames);
 	}
 	function getFieldState(name) {
+		if (__DEV__) {
+			const syntaxError = validatePathSyntax(name);
+			if (syntaxError) warnInvalidPath("getFieldState", name, syntaxError);
+			else {
+				const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
+				if (!schemaResult.valid) warnPathNotInSchema("getFieldState", name, schemaResult.availableFields);
+			}
+		}
 		const error = get(ctx.errors.value, name);
 		return {
 			isDirty: ctx.dirtyFields.value[name] === true,
@@ -1017,6 +1524,17 @@ function useForm(options) {
 		};
 	}
 	async function trigger(name) {
+		if (__DEV__ && name) {
+			const names = Array.isArray(name) ? name : [name];
+			for (const n of names) {
+				const syntaxError = validatePathSyntax(n);
+				if (syntaxError) warnInvalidPath("trigger", n, syntaxError);
+				else {
+					const schemaResult = validatePathAgainstSchema(ctx.options.schema, n);
+					if (!schemaResult.valid) warnPathNotInSchema("trigger", n, schemaResult.availableFields);
+				}
+			}
+		}
 		if (name === void 0) return await validate();
 		if (Array.isArray(name)) {
 			let allValid = true;