notform 3.0.1 → 4.0.0-alpha.1

package/dist/index.js

@@ -1,945 +1,1258 @@
-import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, defineComponent, guardReactiveProps, inject, mergeProps, nextTick, normalizeProps, onMounted, onUnmounted, openBlock, provide, reactive, ref, renderSlot, resolveDynamicComponent, toDisplayString, toValue, unref, watch, withCtx, withModifiers } from "vue";
-import { deepKeys, deleteProperty, getProperty, parsePath, setProperty, stringifyPath } from "dot-prop";
+import { computed, createBlock, createCommentVNode, createElementBlock, createTextVNode, defineComponent, getCurrentScope, mergeProps, normalizeProps, onScopeDispose, openBlock, reactive, readonly, ref, renderSlot, resolveDynamicComponent, shallowReactive, shallowRef, toDisplayString, toRaw, toValue, triggerRef, watch, withCtx, withModifiers } from "vue";
 import { dequal } from "dequal";
 import { klona } from "klona";
-//#region src/utils/segments.ts
+import { getProperty, parsePath, setProperty } from "dot-prop";
+// src/components/array-field.vue
+var array_field_default = /* @__PURE__ */ defineComponent({
+	inheritAttrs: false,
+	__name: "array-field",
+	props: { arrayField: {
+		type: Object,
+		required: true
+	} },
+	setup(__props) {
+		/** `props.arrayField` is the field created by `form.arrayField('some.path')`. */
+		const props = __props;
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", mergeProps({ arrayField: props.arrayField }, _ctx.$attrs));
+		};
+	}
+});
+// src/components/field-error.vue
+var field_error_default = /* @__PURE__ */ defineComponent({
+	inheritAttrs: false,
+	__name: "field-error",
+	props: {
+		as: {
+			type: null,
+			required: false,
+			default: "span"
+		},
+		errors: {
+			type: [Array, Object],
+			required: true
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const message = computed(() => {
+			if (Array.isArray(props.errors)) return props.errors[0]?.message;
+			return props.errors?.errors?.[0]?.message;
+		});
+		return (_ctx, _cache) => {
+			return message.value ? (openBlock(), createBlock(resolveDynamicComponent(props.as), normalizeProps(mergeProps({ key: 0 }, _ctx.$attrs)), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", { message: message.value }, () => [createTextVNode(toDisplayString(message.value), 1)])]),
+				_: 3
+			}, 16)) : createCommentVNode("v-if", true);
+		};
+	}
+});
+// src/components/field.vue
+var field_default = /* @__PURE__ */ defineComponent({
+	inheritAttrs: false,
+	__name: "field",
+	props: { field: {
+		type: Object,
+		required: true
+	} },
+	setup(__props) {
+		/** `props.field` is the field created by `form.field('some.path')`, or an array item. */
+		const props = __props;
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", mergeProps({ field: props.field }, _ctx.$attrs));
+		};
+	}
+});
+// src/components/form.vue
+var form_default = /* @__PURE__ */ defineComponent({
+	inheritAttrs: false,
+	__name: "form",
+	props: { form: {
+		type: Object,
+		required: true
+	} },
+	setup(__props) {
+		/** `props.form` is the form returned by `useForm()`. */
+		const props = __props;
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("form", mergeProps(_ctx.$attrs, {
+				onSubmit: _cache[0] || (_cache[0] = (...args) => props.form.submit && props.form.submit(...args)),
+				onReset: _cache[1] || (_cache[1] = withModifiers((...args) => props.form.reset && props.form.reset(...args), ["prevent"]))
+			}), [renderSlot(_ctx.$slots, "default")], 16);
+		};
+	}
+});
+// src/utils/path.ts
+/**
+* @file
+* Everything that reads, writes, splits or compares paths lives here, so the
+* rest of the code never touches the path library (dot-prop) directly.
+*
+* - PATH      dot-notation text, e.g. 'address.city' or 'tags.0'
+* - SEGMENTS  the same location split into steps, e.g. ['address', 'city'] or ['tags', 0]
+*/
 /**
-* Unwraps a Standard Schema path segment to a property key.
-* @internal
-* @param segment Plain key or `{ key }`.
-* @returns The underlying property key.
+* Reads a path step as an array index.
+* @param segment A path step: `0`, `'0'`, `{ key: 0 }`, ...
+* @returns The index, or `undefined` if the step is not a non-negative integer.
+* @example
+* getSegmentIndex('2') // 2
+* getSegmentIndex('name') // undefined
 */
-function toPropertyKey(segment) {
+function getSegmentIndex(segment) {
+	const key = getSegmentKey(segment);
+	if (typeof key === "number") return Number.isSafeInteger(key) && key >= 0 ? key : void 0;
+	return typeof key === "string" && /^(?:0|[1-9]\d*)$/.test(key) ? Number(key) : void 0;
+}
+/**
+* Reads the key out of a path step, whether it is bare or wrapped.
+* @param segment A path step: `'email'`, `0`, or `{ key: 'email' }`.
+* @returns The plain key.
+* @example
+* getSegmentKey({ key: 'email' }) // 'email'
+*/
+function getSegmentKey(segment) {
 	if (typeof segment === "object" && segment !== null && "key" in segment) return segment.key;
 	return segment;
 }
 /**
-* Whether two path segments name the same property. `0` and `"0"` are equal.
-* @internal
-* @param segmentA First segment.
-* @param segmentB Second segment.
-* @returns `true` when both refer to the same key.
+* Reads the value at a dot-notation path.
+* @param source The object to read from.
+* @param path Dot-notation path, e.g. `'tags.0'`.
+* @returns The value, or `undefined` if any step is missing.
+*/
+function getValueAtPath(source, path) {
+	return getProperty(source, path);
+}
+/**
+* Checks whether a path sits at, or below, a parent path.
+* @param segments The path being tested.
+* @param parentSegments The path it should start with.
+* @returns `true` if `segments` equals `parentSegments` or is nested deeper.
+* @example
+* isPathInside(['user', 'name'], ['user']) // true
+* isPathInside(['user'], ['user']) // true
+* isPathInside(['user'], ['user', 'name']) // false
 */
-function areSegmentsEqual(segmentA, segmentB) {
-	const keyA = toPropertyKey(segmentA);
-	const keyB = toPropertyKey(segmentB);
-	if (typeof keyA === "number" && typeof keyB === "string") return Number.isSafeInteger(Number(keyB)) && keyA === Number(keyB);
-	if (typeof keyA === "string" && typeof keyB === "number") return Number.isSafeInteger(Number(keyA)) && Number(keyA) === keyB;
-	return keyA === keyB;
+function isPathInside(segments, parentSegments) {
+	if (segments.length < parentSegments.length) return false;
+	return parentSegments.every((parentSegment, index) => {
+		return isSameSegment(segments[index], parentSegment);
+	});
+}
+/**
+* Checks whether two paths point at exactly the same place.
+* @param firstSegments The first path (e.g. an issue's `path`).
+* @param secondSegments The second path.
+* @returns `true` if both exist, have the same length, and every step matches.
+* @remarks A missing path means "the whole form", so it never equals anything, not even another missing path.
+* @example
+* isSamePath(['tags', 0], ['tags', '0']) // true
+* isSamePath(undefined, undefined) // false
+*/
+function isSamePath(firstSegments, secondSegments) {
+	if (!firstSegments || !secondSegments || firstSegments.length !== secondSegments.length) return false;
+	return firstSegments.every((segment, index) => {
+		return isSameSegment(segment, secondSegments[index]);
+	});
 }
 /**
-* Whether `pathSegments` names the same field as `scopeSegments`, or a field
-* nested underneath it, at any depth.
+* Checks whether two path steps are the same key.
 *
-* This is the general **"at-or-under"** test: `isPathWithinScope(path, scope)`
-* is `true` when `path` equals `scope` exactly, or when `path` extends
-* `scope` with one or more extra trailing segments. It underlies both
-* {@linkcode locatePathInArrayField} (which additionally requires at least one
-* extra segment, since it locates a specific item) and the recursive
-* `isValid`/`isTouched`/`isDirty`/`isValidating` aggregates on
-* `<NotArrayField>`, which allow zero extra segments too, since the array's
-* own path should count toward its own aggregate.
-* @template TPathSegment Segment type of the candidate path.
-* @template TScopeSegment Segment type of the scope path.
-* @internal
-* @param pathSegments Candidate path, already split.
-* @param scopeSegments Scope path, already split.
-* @returns `true` when `pathSegments` is `scopeSegments` or a descendant of it.
-*/
-function isPathWithinScope(pathSegments, scopeSegments) {
-	if (pathSegments.length < scopeSegments.length) return false;
-	return scopeSegments.every((scopeSegment, segmentIndex) => areSegmentsEqual(pathSegments[segmentIndex], scopeSegment));
-}
-//#endregion
-//#region src/utils/array-field.ts
-/**
-* Locates a field path inside an array field, e.g. `users.1.email` under
-* `users`, or `users.1.addresses.0.city` under `users` — `remainingPathSegments`
-* holds whatever comes after the index, however many segments deep that is.
-* @template TPathSegment Segment type of the candidate path.
-* @template TArraySegment Segment type of the array field path.
-* @internal
-* @param pathSegments Candidate path, already split.
-* @param arrayFieldPathSegments Array field path, already split.
-* @returns Item index and leftover segments, or `undefined` when the path is not inside the array.
-*/
-function locatePathInArrayField(pathSegments, arrayFieldPathSegments) {
-	if (pathSegments.length <= arrayFieldPathSegments.length || !isPathWithinScope(pathSegments, arrayFieldPathSegments)) return;
-	const itemIndexSegment = toPropertyKey(pathSegments[arrayFieldPathSegments.length]);
-	if (typeof itemIndexSegment !== "number" && typeof itemIndexSegment !== "string") return;
-	const itemIndex = Number(itemIndexSegment);
-	if (!Number.isSafeInteger(itemIndex) || itemIndex < 0) return;
+* `0` equals `'0'` because schema libraries disagree on whether array indexes
+* are numbers or strings. Wrapped keys (`{ key }`) are unwrapped first.
+* @param firstSegment The first step.
+* @param secondSegment The second step.
+* @returns `true` if both steps refer to the same key.
+*/
+function isSameSegment(firstSegment, secondSegment) {
+	const firstKey = getSegmentKey(firstSegment);
+	const secondKey = getSegmentKey(secondSegment);
+	if (typeof firstKey === "number" && typeof secondKey === "string") return Number.isSafeInteger(firstKey) && String(firstKey) === secondKey;
+	if (typeof firstKey === "string" && typeof secondKey === "number") return Number.isSafeInteger(secondKey) && firstKey === String(secondKey);
+	return firstKey === secondKey;
+}
+/**
+* Appends one step to a path.
+* @param parentPath The parent path. An empty string means the form root.
+* @param key The step to append (property name or array index).
+* @returns The combined path.
+* @example
+* joinPath('tags', 1) // 'tags.1'
+* joinPath('', 'name') // 'name'
+*/
+function joinPath(parentPath, key) {
+	return parentPath === "" ? String(key) : `${parentPath}.${key}`;
+}
+/**
+* Writes a value at a dot-notation path, creating missing steps.
+* @param target The object to write into (modified in place).
+* @param path Dot-notation path, e.g. `'address.city'`.
+* @param value The value to write.
+*/
+function setValueAtPath(target, path, value) {
+	setProperty(target, path, value);
+}
+/**
+* Splits a dot-notation path into its steps.
+* @param path Dot-notation path, e.g. `'tags.0.name'`.
+* @returns The steps, e.g. `['tags', '0', 'name']` (indexes may be strings or numbers).
+*/
+function splitPath(path) {
+	return parsePath(path);
+}
+// src/utils/validation-issue.ts
+/** Message used when something was thrown that carries no readable text. */
+const FALLBACK_VALIDATION_ERROR_MESSAGE = "Validation failed";
+/**
+* Turns anything thrown during validation into a regular issue, so a crashing
+* schema shows up as a form error instead of an unhandled exception.
+* @param error Whatever was thrown.
+* @param path Dot-notation path of the field being validated. Leave out for a form-level error.
+* @returns An issue carrying the error's message.
+* @example
+* createValidationIssueFromError(new Error('Down'), 'email') // { message: 'Down', path: ['email'] }
+*/
+function createValidationIssueFromError(error, path) {
+	const message = getErrorMessage(error);
+	return path ? {
+		message,
+		path: splitPath(path)
+	} : { message };
+}
+/**
+* Re-points an issue that lives inside an array after the array was mutated.
+* @param issue The issue to adjust.
+* @param arraySegments Path of the mutated array.
+* @param mapIndex Translates an item's old index to its new one.
+* @returns The same issue when it is unaffected, a copy with the new index when the
+* item moved, or `undefined` when the item no longer exists.
+*/
+function remapIssueIndex(issue, arraySegments, mapIndex) {
+	const { path } = issue;
+	if (!path || path.length <= arraySegments.length || !isPathInside(path, arraySegments)) return issue;
+	const oldIndex = getSegmentIndex(path[arraySegments.length]);
+	if (oldIndex === void 0) return issue;
+	const newIndex = mapIndex(oldIndex);
+	if (newIndex === void 0) return;
+	if (newIndex === oldIndex) return issue;
 	return {
-		index: itemIndex,
-		remainingPathSegments: pathSegments.slice(arrayFieldPathSegments.length + 1)
+		...issue,
+		path: [
+			...path.slice(0, arraySegments.length),
+			newIndex,
+			...path.slice(arraySegments.length + 1)
+		]
 	};
 }
 /**
-* Rewrites paths in a set after an array mutation. Paths outside the array are left as-is.
-* @template TSchema The form schema.
-* @internal
-* @param paths Touched or dirty path set.
-* @param arraySegments Split array field path.
-* @param remapIndex Previous item index → next index, or `undefined` if removed.
-*/
-function remapPathSet(paths, arraySegments, remapIndex) {
-	const pathsToRemove = [];
-	const pathsToAdd = [];
-	for (const path of paths) {
-		const location = locatePathInArrayField(parsePath(path), arraySegments);
-		if (!location) continue;
-		pathsToRemove.push(path);
-		const nextIndex = remapIndex(location.index);
-		if (nextIndex === void 0) continue;
-		const nextPath = stringifyPath([
-			...arraySegments,
-			nextIndex,
-			...location.remainingPathSegments
-		], { preferDotForIndices: true });
-		pathsToAdd.push(nextPath);
-	}
-	for (const path of pathsToRemove) paths.delete(path);
-	for (const path of pathsToAdd) paths.add(path);
-}
-/**
-* Moves touched, dirty, and error state with array items after a structural
-* mutation. Because {@linkcode locatePathInArrayField} keeps whatever follows the
-* item's index as `remainingPathSegments`, this already handles state nested
-* arbitrarily deep inside an item — a field on an object item, or an item
-* inside a nested array of its own — not just the item's own top-level path.
+* Extracts readable text from a thrown value.
+* @param error Whatever was thrown.
+* @returns The `Error` message, the string itself, or a generic fallback.
+*/
+function getErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	return FALLBACK_VALIDATION_ERROR_MESSAGE;
+}
+// src/utils/validation-scope.ts
+/**
+* Checks whether a new run makes an older run pointless.
 *
-* Validating state is not remapped; generation tracking already drops stale results.
-* @template TSchema The form schema.
-* @internal
-* @param form Full form instance.
-* @param arrayPath Dot path of the array field.
-* @param remapIndex Previous item index → next index, or `undefined` if removed.
-*/
-function remapArrayFieldState(form, arrayPath, remapIndex) {
-	const arraySegments = parsePath(arrayPath);
-	remapPathSet(form.touchedFields, arraySegments, remapIndex);
-	remapPathSet(form.dirtyFields, arraySegments, remapIndex);
-	const remappedErrors = [];
-	for (const issue of form.errors) {
-		if (!issue.path) {
-			remappedErrors.push(issue);
-			continue;
-		}
-		const location = locatePathInArrayField(issue.path, arraySegments);
-		if (!location) {
-			remappedErrors.push(issue);
-			continue;
-		}
-		const nextIndex = remapIndex(location.index);
-		if (nextIndex === void 0) continue;
-		remappedErrors.push({
-			...issue,
-			path: [
-				...arraySegments,
-				nextIndex,
-				...location.remainingPathSegments
-			]
-		});
-	}
-	form.replaceErrors(remappedErrors);
+* A field run only writes the errors of its own path, so it only replaces an
+* older run of that same path. A whole-form run writes everything, so it
+* replaces any older run.
+* @param coveringScope Scope of the new run.
+* @param coveredScope Scope of the older run.
+* @returns `true` if the older run's result would be overwritten anyway.
+*/
+function doesScopeCover(coveringScope, coveredScope) {
+	if (coveringScope.type === "form") return true;
+	return coveredScope.type === "field" && isSamePath(coveringScope.segments, coveredScope.segments);
 }
-//#endregion
-//#region src/utils/instance.ts
 /**
-* Injection key for the full {@linkcode NotFormInstance}.
-* @internal
+* Builds the scope of a validation run.
+* @param path Dot-notation field path. Leave out to cover the whole form.
+* @returns A field scope when `path` is given, otherwise a whole-form scope.
+* @example
+* getValidationScope('tags.0') // { segments: ['tags', '0'], type: 'field' }
 */
-const NOT_FORM_INSTANCE_KEY = Symbol("notform:instance");
+function getValidationScope(path) {
+	if (path === void 0) return { type: "form" };
+	return {
+		segments: splitPath(path),
+		type: "field"
+	};
+}
 /**
-* Provides the full form instance to descendants.
-* @template TSchema The form schema.
-* @internal
-* @param instance Public API or full instance.
+* Checks whether a running validation concerns a field, for `isValidating` flags.
+* A field counts as validating while the whole form, the field itself, or any
+* field nested inside it is being validated.
+* @param runScope Scope of the running validation.
+* @param fieldSegments Path of the field being asked about.
+* @returns `true` if the run concerns the field.
 */
-function provideNotFormInstance(instance) {
-	provide(NOT_FORM_INSTANCE_KEY, toNotFormInstance(instance));
+function isFieldAffectedByScope(runScope, fieldSegments) {
+	if (runScope.type === "form") return true;
+	return isPathInside(runScope.segments, fieldSegments);
 }
-function toNotFormInstance(form) {
-	return form;
+// src/utils/array.ts
+/**
+* Forces an index into `0..max` (inclusive). `NaN` becomes `0`, `Infinity` becomes `max`.
+* @param index The requested index.
+* @param max The highest allowed index.
+* @returns The clamped integer index.
+*/
+function clampIndex(index, max) {
+	return Math.min(Math.max(Math.trunc(index) || 0, 0), max);
 }
-//#endregion
-//#region src/composables/use-not-form-instance.ts
 /**
-* Resolves the full form instance from `explicitInstance` or inject.
-* @template TSchema The form schema.
-* @internal
-* @param explicitInstance Optional `form` prop, preferred over inject.
-* @returns The resolved instance.
-* @throws If neither prop nor inject is available.
+* Maps indexes after an item was replaced in place: the replaced item is gone, the rest stay.
+* @param at Index of the replaced item.
+* @returns The mapper.
 */
-function useNotFormInstance(explicitInstance) {
-	const injectedInstance = inject(NOT_FORM_INSTANCE_KEY, void 0);
-	const resolvedInstance = toNotFormInstance(explicitInstance) ?? injectedInstance;
-	if (!resolvedInstance) throw new Error(`
-      [NotForm] No NotForm instance found.
-      Wrap with <NotForm :form="[instance]"> or pass :form="[instance]" directly to the component.
-      `);
-	return resolvedInstance;
+function createDiscardMapper(at) {
+	return (index) => {
+		return index === at ? void 0 : index;
+	};
 }
-//#endregion
-//#region src/composables/use-not-array-field.ts
 /**
-* Array-field state, stable item keys, and mutation helpers for `<NotArrayField>`.
+* Maps indexes after an item was inserted: everything from `at` on shifts up by one.
+* @param at Index the new item was inserted at.
+* @returns The mapper.
+*/
+function createInsertMapper(at) {
+	return (index) => {
+		return index >= at ? index + 1 : index;
+	};
+}
+/**
+* Maps indexes after an item moved from `from` to `to`.
+* @param from Index the item left.
+* @param to Index the item landed on.
+* @returns The mapper.
+*/
+function createMoveMapper(from, to) {
+	return (index) => {
+		if (index === from) return to;
+		if (from < to && index > from && index <= to) return index - 1;
+		if (from > to && index >= to && index < from) return index + 1;
+		return index;
+	};
+}
+/**
+* Maps indexes after an item was removed: the removed item is gone, later ones shift down by one.
+* @param at Index of the removed item.
+* @returns The mapper.
+*/
+function createRemoveMapper(at) {
+	return (index) => {
+		if (index === at) return;
+		return index > at ? index - 1 : index;
+	};
+}
+/**
+* Maps indexes after two items traded places.
+* @param indexA Index of the first item.
+* @param indexB Index of the second item.
+* @returns The mapper.
+*/
+function createSwapMapper(indexA, indexB) {
+	return (index) => {
+		if (index === indexA) return indexB;
+		return index === indexB ? indexA : index;
+	};
+}
+/**
+* Checks that an index points at an existing item.
+* @param index The index to test.
+* @param length The length of the list.
+* @returns `true` for an integer in `0..length - 1`.
+*/
+function isIndexInRange(index, length) {
+	return Number.isSafeInteger(index) && index >= 0 && index < length;
+}
+/**
+* Moves one item inside a list, in place. Both indexes must be in range.
+* @param list The list to change.
+* @param from Current index of the item.
+* @param to Index the item should end up at.
+*/
+function moveListItem(list, from, to) {
+	const [item] = list.splice(from, 1);
+	list.splice(to, 0, item);
+}
+/**
+* Swaps two items of a list, in place. Both indexes must be in range.
+* @param list The list to change.
+* @param indexA Index of the first item.
+* @param indexB Index of the second item.
+*/
+function swapListItems(list, indexA, indexB) {
+	const first = list[indexA];
+	list[indexA] = list[indexB];
+	list[indexB] = first;
+}
+// src/utils/id.ts
+let lastIssuedNumber = 0;
+/**
+* Creates the unique, stable identity of a field.
 *
-* `itemKeys` is the only source of `item.key`. Length-only external changes
-* pad or trim keys from the end; use the mutation helpers to keep identity
-* through insert, remove, swap, and move.
+* The number in the description is a debugging aid only; always compare ids by reference.
+* @param kind What the id is for.
+* @returns A new symbol, e.g. `notform.field.3`.
+*/
+function createFieldId(kind) {
+	lastIssuedNumber += 1;
+	return Symbol(`notform.${kind}.${lastIssuedNumber}`);
+}
+// src/utils/debounce.ts
+/**
+* Cleans up a debounce delay so it is always safe to hand to `setTimeout`.
+* @param delayInMilliseconds The delay requested by the user, if any.
+* @returns `undefined` when no delay was given; otherwise the delay clamped to
+* `0` or more (negative, `NaN` and `Infinity` all become `0`).
+* @example
+* normalizeDebounce(undefined) // undefined
+* normalizeDebounce(-50) // 0
+*/
+function normalizeDebounce(delayInMilliseconds) {
+	if (delayInMilliseconds === void 0) return;
+	return Number.isFinite(delayInMilliseconds) ? Math.max(0, delayInMilliseconds) : 0;
+}
+// src/factories/create-field.ts
+/**
+* Creates a field: a small reactive handle bound to one value inside a form.
+* @template TValue - Type of the value the field holds.
+* @param host The form the field belongs to.
+* @param options Identity, path source and behavior.
+* @returns The field instance and its teardown.
+* @remarks Internal. Use `form.field(path)`, which caches the result.
+*/
+function createField(host, options) {
+	const { dispose, parts } = createFieldState(host, options);
+	return {
+		dispose,
+		instance: reactive(parts)
+	};
+}
+/**
+* Builds the state every kind of field shares (plain field, array field, array item).
 *
-* `isValid`/`isTouched`/`isDirty`/`isValidating` are recursive: they reflect
-* the array field's own path plus every path nested underneath it, at any
-* depth — an item's own value, a field inside an object item, or an item
-* inside a nested array. `errors`, by contrast, is intentionally exact: it
-* only ever reflects issues reported at the array field's own path, the same
-* way `<NotField>`'s `errors` only reflects issues at that one field's path.
-* @template TSchema The form schema.
-* @template TItemSchema Schema used only to type mutation values.
-* @internal
-* @param props Array field path, optional form, and optional item schema.
-* @returns Slot state for `<NotArrayField>`.
-*/
-function useNotArrayField(props) {
-	const form = useNotFormInstance(props.form);
-	/** Monotonic id used by {@linkcode createItemKey}. */
-	let nextItemKeyId = 0;
-	/** Stable identity per current array index; mutated in lockstep with values. */
-	const itemKeys = ref([]);
-	/** Live array at `props.path`, or `[]` when the path is missing or not an array. */
-	const arrayValue = computed(() => {
-		const value = getProperty(form.values, props.path);
-		return Array.isArray(value) ? value : [];
+* The field owns no data: `model` reads and writes straight into the form's values,
+* and the path is resolved on every read, so the field stays correct when it moves.
+* @template TValue - Type of the value the field holds.
+* @param host The form the field belongs to.
+* @param options Identity, path source and behavior.
+* @returns `parts`, the raw members (computed refs and functions) to wrap in `reactive()`, `dispose`,
+* and `isDisposed`. A disposed field is inert: events, writes and validation do nothing.
+*/
+function createFieldState(host, options) {
+	const id = options.id ?? createFieldId("field");
+	const config = resolveFieldConfig(options.config);
+	let isDisposed = false;
+	let lastKnownPath = "";
+	/** Current path. Frozen at its last value once the field is disposed. */
+	const path = computed(() => {
+		if (!isDisposed) lastKnownPath = options.getPath();
+		return lastKnownPath;
 	});
-	/** Slot items: current index, stored key, and index-based path. */
-	const items = computed(() => arrayValue.value.map((_, index) => ({
-		index,
-		key: itemKeys.value[index] ?? "",
-		path: `${props.path}.${index}`
-	})));
-	/** `props.path`, pre-split into segments, for the scope checks below. */
-	const arrayPathSegments = computed(() => parsePath(props.path));
-	/** Issues reported exactly at this array field's own path — never issues from items. */
-	const errors = computed(() => form.getFieldErrors(props.path));
-	/**
-	* Whether the array field's own path, or any path nested under it — an
-	* item, a field inside an object item, or an item inside a nested array —
-	* has an active issue. Unlike `errors` above, this recurses to any depth.
-	* Issues without a `path` are never attributed to a specific field, so
-	* they don't affect this — only the top-level `form.isValid` reflects them.
-	*/
-	const isValid = computed(() => {
-		return form.errors.every((issue) => issue.path === void 0 || !isPathWithinScope(issue.path, arrayPathSegments.value));
+	/** Two-way link to the form's value at `path`. */
+	const model = computed({
+		get: () => {
+			return host.getValue(path.value);
+		},
+		set: (value) => {
+			if (!isDisposed) host.setValue(path.value, value);
+		}
+	});
+	const isDirty = computed(() => {
+		return !dequal(model.value, host.getInitialValue(path.value));
 	});
-	/** Whether the array field's own path, or any path nested under it, has been touched. */
 	const isTouched = computed(() => {
-		return [...form.touchedFields].some((touchedPath) => isPathWithinScope(parsePath(touchedPath), arrayPathSegments.value));
+		return host.isFieldTouched(id);
 	});
-	/** Whether the array field's own path, or any path nested under it, differs from the baseline. */
-	const isDirty = computed(() => {
-		return [...form.dirtyFields].some((dirtyPath) => isPathWithinScope(parsePath(dirtyPath), arrayPathSegments.value));
+	const errors = computed(() => {
+		return host.getFieldErrors(path.value);
+	});
+	const isValid = computed(() => {
+		return errors.value.length === 0;
 	});
-	/** Whether the array field's own path, or any path nested under it, is currently validating. */
 	const isValidating = computed(() => {
-		return [...form.validatingFields].some((validatingPath) => isPathWithinScope(parsePath(validatingPath), arrayPathSegments.value));
+		return host.isFieldValidating(path.value);
 	});
-	/**
-	* Allocates a unique key for one array item.
-	* @returns A key that never repeats in this field instance.
-	*/
-	function createItemKey() {
-		return `notform-array-item-${nextItemKeyId++}`;
+	function validate() {
+		if (isDisposed) return Promise.resolve({ value: void 0 });
+		host.cancelFieldTask(id);
+		return host.validateField(path.value);
 	}
 	/**
-	* Pads or trims `itemKeys` from the end so it matches `targetLength`.
-	* @param targetLength Desired key count.
+	* Validates in response to `change` / `input`, honouring `validateOn`, the mode and the debounce.
+	* @param event The event that fired.
 	*/
-	function syncItemKeysToLength(targetLength) {
-		while (itemKeys.value.length < targetLength) itemKeys.value.push(createItemKey());
-		if (itemKeys.value.length > targetLength) itemKeys.value.length = targetLength;
+	function validateOnEvent(event) {
+		if (isDisposed) return;
+		if (!(config.validateOn[event] || config.validationMode === "eager" && errors.value.length > 0)) return;
+		if (config.debounce) {
+			host.scheduleFieldTask(id, config.debounce, () => {
+				validate();
+			});
+			return;
+		}
+		validate();
+	}
+	function onBlur() {
+		if (isDisposed) return;
+		host.touchField(id);
+		if (config.validateOn.blur) validate();
+	}
+	function onChange() {
+		validateOnEvent("change");
 	}
+	function onInput() {
+		validateOnEvent("input");
+	}
+	function dispose() {
+		if (isDisposed) return;
+		if (lastKnownPath === "") lastKnownPath = options.getPath();
+		isDisposed = true;
+		host.cancelFieldTask(id);
+		host.untouchField(id);
+	}
+	return {
+		dispose,
+		isDisposed: () => {
+			return isDisposed;
+		},
+		parts: {
+			errors,
+			events: {
+				onBlur,
+				onChange,
+				onInput
+			},
+			id,
+			isDirty,
+			isTouched,
+			isValid,
+			isValidating,
+			model,
+			path,
+			validate
+		}
+	};
+}
+/**
+* Merges the user's config over the defaults.
+* @param config The config passed to `form.field()`.
+* @returns A complete config (blur and change validate, input does not; eager mode).
+*/
+function resolveFieldConfig(config) {
+	return {
+		debounce: normalizeDebounce(config?.debounce),
+		validateOn: {
+			blur: config?.validateOn?.blur ?? true,
+			change: config?.validateOn?.change ?? true,
+			input: config?.validateOn?.input ?? false
+		},
+		validationMode: config?.validationMode ?? "eager"
+	};
+}
+// src/factories/create-array-field.ts
+/**
+* Creates an array field: a field for the array itself, plus one stable identity
+* per item and the mutations that keep values, ids and errors in step.
+*
+* Bookkeeping lives in one place: `ids`, a list parallel to the array.
+* - Every mutation edits the array, `ids` and the form's errors together.
+* - If the array is changed behind our back, `ids` is reconciled by length the next
+* time it is read (new ids at the end, extra ids dropped). On form reset all ids are renewed.
+* - Once the field is disposed (its item was removed) it is inert: mutations do nothing and
+* `items` is empty, so a stale handle can never write into the item that took its place.
+* @template TItem - Type of one array item.
+* @param host The form the field belongs to.
+* @param options Path source, behavior and the scope factory for nested fields.
+* @returns The array field instance and its teardown.
+* @remarks Internal. Use `form.arrayField(path)`, which caches the result.
+*/
+function createArrayField(host, options) {
+	const base = createFieldState(host, {
+		config: options.config,
+		getPath: options.getPath,
+		id: createFieldId("array-field")
+	});
+	const arrayPath = base.parts.path;
+	/** One id per array item, same order as the array. Mutated in place; `triggerRef` announces changes. */
+	const ids = shallowRef([]);
+	/** Item fields by id, created on demand. */
+	const itemNodes = /* @__PURE__ */ new Map();
+	/** The form's reset count when `ids` was last in sync. */
+	let seenResetCount = host.getResetCount();
 	/**
-	* Returns the mutable array at `props.path`, creating an empty array if needed.
-	* @returns The live array stored on the form.
+	* Reads the array this field points at.
+	* @returns The reactive array, or `undefined` if the value is missing or not an array.
 	*/
-	function getOrCreateArrayValue() {
-		const existingArray = getProperty(form.values, props.path);
-		if (Array.isArray(existingArray)) return existingArray;
-		const createdArray = [];
-		setProperty(form.values, props.path, createdArray);
-		return createdArray;
+	function readArray() {
+		const value = host.getValue(arrayPath.value);
+		return Array.isArray(value) ? value : void 0;
 	}
 	/**
-	* Moves one element inside `target` from `fromIndex` to `toIndex`.
-	* @template TItem Element type.
-	* @param target Array to mutate in place.
-	* @param fromIndex Index of the element to move.
-	* @param toIndex Destination index, clamped to the array bounds.
+	* Reads the array, creating an empty one if the value is missing.
+	* @returns The reactive array.
+	* @throws {TypeError} If an array cannot be created at the path.
 	*/
-	function moveArrayItem(target, fromIndex, toIndex) {
-		if (fromIndex === toIndex || fromIndex < 0 || fromIndex >= target.length) return;
-		const clampedToIndex = Math.max(0, Math.min(toIndex, target.length - 1));
-		const [movedItem] = target.splice(fromIndex, 1);
-		target.splice(clampedToIndex, 0, movedItem);
+	function ensureArray() {
+		const existing = readArray();
+		if (existing) return existing;
+		host.setValue(arrayPath.value, []);
+		const created = readArray();
+		if (!created) throw new TypeError(`[notform] Cannot create an array at "${arrayPath.value}"`);
+		return created;
 	}
 	/**
-	* Appends `value` and a new key at the end of the array.
-	* @param value Item to append.
+	* Tears down item fields whose ids left the list.
+	* @param removedIds The ids that were removed.
+	* @param isDeferred Run the teardown in a microtask. Needed when called while a computed is
+	* evaluating, because teardown writes reactive state (the touched set).
 	*/
-	function append(value) {
-		getOrCreateArrayValue().push(value);
-		itemKeys.value.push(createItemKey());
+	function releaseItems(removedIds, isDeferred) {
+		for (const removedId of removedIds) {
+			const node = itemNodes.get(removedId);
+			if (!node) continue;
+			itemNodes.delete(removedId);
+			if (isDeferred) queueMicrotask(node.dispose);
+			else node.dispose();
+		}
 	}
 	/**
-	* Inserts `value` at the start and remaps later item state — at any depth
-	* underneath each item — up by one.
-	* @param value Item to prepend.
+	* Brings `ids` in line with the array, then returns it.
+	* @returns The id list (same length as the array).
 	*/
-	function prepend(value) {
-		getOrCreateArrayValue().unshift(value);
-		itemKeys.value.unshift(createItemKey());
-		remapArrayFieldState(form, props.path, (previousIndex) => previousIndex + 1);
+	function syncIds() {
+		const list = ids.value;
+		if (base.isDisposed()) return list;
+		const resetCount = host.getResetCount();
+		if (resetCount !== seenResetCount) {
+			seenResetCount = resetCount;
+			releaseItems(list.splice(0), true);
+		}
+		const length = readArray()?.length ?? 0;
+		while (list.length < length) list.push(createFieldId("array-item"));
+		if (list.length > length) releaseItems(list.splice(length), true);
+		return list;
 	}
 	/**
-	* Inserts `value` at `index` and remaps later item state — at any depth
-	* underneath each item — up by one.
-	* @param index Insertion index.
-	* @param value Item to insert.
+	* Announces a finished mutation: refreshes `items` and validates per the field's config.
 	*/
+	function commit() {
+		triggerRef(ids);
+		base.parts.events.onChange();
+	}
 	function insert(index, value) {
-		getOrCreateArrayValue().splice(index, 0, value);
-		itemKeys.value.splice(index, 0, createItemKey());
-		remapArrayFieldState(form, props.path, (previousIndex) => previousIndex >= index ? previousIndex + 1 : previousIndex);
+		if (base.isDisposed()) return;
+		const list = syncIds();
+		const array = ensureArray();
+		const at = clampIndex(index, list.length);
+		list.splice(at, 0, createFieldId("array-item"));
+		array.splice(at, 0, cloneValue(value));
+		host.remapArrayErrors(arrayPath.value, createInsertMapper(at));
+		commit();
+	}
+	function append(value) {
+		insert(syncIds().length, value);
+	}
+	function prepend(value) {
+		insert(0, value);
 	}
-	/**
-	* Removes the item at `index` and remaps later item state — at any depth
-	* underneath each item — down by one. State nested under the removed
-	* item's own path, at any depth, is discarded along with it.
-	* @param index Index to remove.
-	*/
 	function remove(index) {
-		getOrCreateArrayValue().splice(index, 1);
-		itemKeys.value.splice(index, 1);
-		remapArrayFieldState(form, props.path, (previousIndex) => {
-			if (previousIndex === index) return;
-			return previousIndex > index ? previousIndex - 1 : previousIndex;
-		});
+		const list = syncIds();
+		if (base.isDisposed() || !isIndexInRange(index, list.length)) return;
+		releaseItems(list.splice(index, 1), false);
+		ensureArray().splice(index, 1);
+		host.remapArrayErrors(arrayPath.value, createRemoveMapper(index));
+		commit();
+	}
+	function move(from, to) {
+		const list = syncIds();
+		if (from === to || base.isDisposed() || !isIndexInRange(from, list.length) || !isIndexInRange(to, list.length)) return;
+		moveListItem(list, from, to);
+		moveListItem(ensureArray(), from, to);
+		host.remapArrayErrors(arrayPath.value, createMoveMapper(from, to));
+		commit();
+	}
+	function swap(indexA, indexB) {
+		const list = syncIds();
+		if (indexA === indexB || base.isDisposed() || !isIndexInRange(indexA, list.length) || !isIndexInRange(indexB, list.length)) return;
+		swapListItems(list, indexA, indexB);
+		swapListItems(ensureArray(), indexA, indexB);
+		host.remapArrayErrors(arrayPath.value, createSwapMapper(indexA, indexB));
+		commit();
 	}
-	/**
-	* Replaces the value at `index` without changing its key.
-	* @param index Index to update.
-	* @param value New item value.
-	*/
 	function update(index, value) {
-		getOrCreateArrayValue()[index] = value;
+		if (base.isDisposed() || !isIndexInRange(index, syncIds().length)) return;
+		ensureArray()[index] = cloneValue(value);
+		host.remapArrayErrors(arrayPath.value, createDiscardMapper(index));
+		commit();
 	}
 	/**
-	* Swaps two items, moving keys and form state — at any depth underneath
-	* each item — with them.
-	* @param indexA First index.
-	* @param indexB Second index.
+	* Creates the field of one array item.
+	* @param id The item's id.
+	* @returns The item instance and its teardown.
 	*/
-	function swap(indexA, indexB) {
-		const array = getOrCreateArrayValue();
-		[array[indexA], array[indexB]] = [array[indexB], array[indexA]];
-		[itemKeys.value[indexA], itemKeys.value[indexB]] = [itemKeys.value[indexB], itemKeys.value[indexA]];
-		remapArrayFieldState(form, props.path, (previousIndex) => {
-			if (previousIndex === indexA) return indexB;
-			if (previousIndex === indexB) return indexA;
-			return previousIndex;
+	function createItemNode(id) {
+		let lastIndex = ids.value.indexOf(id);
+		/** Position of the item. Keeps its last value once the item is gone, so its path never turns into `-1`. */
+		const index = computed(() => {
+			const currentIndex = syncIds().indexOf(id);
+			if (currentIndex !== -1) lastIndex = currentIndex;
+			return lastIndex;
+		});
+		const getItemPath = () => {
+			return joinPath(arrayPath.value, index.value);
+		};
+		const scope = options.createScope(getItemPath);
+		const state = createFieldState(host, {
+			config: options.config,
+			getPath: getItemPath,
+			id
 		});
+		return {
+			dispose: () => {
+				scope.dispose();
+				state.dispose();
+			},
+			instance: reactive({
+				...state.parts,
+				arrayField: scope.arrayField,
+				field: scope.field,
+				index
+			})
+		};
 	}
 	/**
-	* Moves one item to `toIndex`, shifting neighbors and remapping form
-	* state — at any depth underneath each item.
-	* @param fromIndex Current index.
-	* @param toIndex Destination index.
+	* Gets or creates the field of the item with this id.
+	* @param id The item's id.
+	* @returns The cached item instance.
 	*/
-	function move(fromIndex, toIndex) {
-		moveArrayItem(getOrCreateArrayValue(), fromIndex, toIndex);
-		moveArrayItem(itemKeys.value, fromIndex, toIndex);
-		remapArrayFieldState(form, props.path, (previousIndex) => {
-			if (previousIndex === fromIndex) return toIndex;
-			if (fromIndex < toIndex) return previousIndex > fromIndex && previousIndex <= toIndex ? previousIndex - 1 : previousIndex;
-			return previousIndex >= toIndex && previousIndex < fromIndex ? previousIndex + 1 : previousIndex;
-		});
+	function getItem(id) {
+		let node = itemNodes.get(id);
+		if (!node) {
+			node = createItemNode(id);
+			itemNodes.set(id, node);
+		}
+		return node.instance;
 	}
-	watch(() => arrayValue.value.length, (arrayLength) => {
-		if (itemKeys.value.length === arrayLength) return;
-		syncItemKeysToLength(arrayLength);
-	}, { immediate: true });
-	return reactive({
-		append,
-		errors,
-		insert,
-		isDirty,
-		isTouched,
-		isValid,
-		isValidating,
-		items,
-		move,
-		path: computed(() => props.path),
-		prepend,
-		remove,
-		swap,
-		update
+	const items = computed(() => {
+		return base.isDisposed() ? [] : syncIds().map((id) => {
+			return getItem(id);
+		});
 	});
+	function dispose() {
+		for (const node of itemNodes.values()) node.dispose();
+		itemNodes.clear();
+		base.dispose();
+	}
+	return {
+		dispose,
+		instance: reactive({
+			...base.parts,
+			append,
+			insert,
+			items,
+			move,
+			prepend,
+			remove,
+			swap,
+			update
+		})
+	};
 }
-//#endregion
-//#region src/components/not-array-field.vue
-var not_array_field_default = /* @__PURE__ */ defineComponent({
-	__name: "not-array-field",
-	props: {
-		path: {
-			type: [String, Object],
-			required: true
-		},
-		itemSchema: {
-			type: null,
-			required: false
-		},
-		form: {
-			type: Object,
-			required: false
+/**
+* Deep-copies a value on its way in, so two items never share one object.
+* @param value The value to copy.
+* @returns The copy.
+*/
+function cloneValue(value) {
+	return klona(toRaw(value));
+}
+// src/factories/create-field-scope.ts
+/**
+* Creates a scope: the place that creates fields under a base path and keeps
+* one instance per relative path.
+*
+* Caching is what gives fields a stable identity. A template may call
+* `form.field('name')` on every render and always gets the same field, so its
+* id, touched state and pending validation survive re-renders.
+* @param host The form the fields belong to.
+* @param getBasePath Returns the base path. The form root uses `() => ''`; an array item
+* uses its own current path, so nested fields follow the item when it moves.
+* @returns The scope. After `dispose()`, fields it still hands out are inert.
+*/
+function createFieldScope(host, getBasePath) {
+	const nodes = /* @__PURE__ */ new Map();
+	let isDisposed = false;
+	function field(path, config) {
+		const key = `field:${path}`;
+		let node = nodes.get(key);
+		if (!node) {
+			node = createField(host, {
+				config,
+				getPath: () => {
+					return joinPath(getBasePath(), path);
+				}
+			});
+			nodes.set(key, node);
+			if (isDisposed) node.dispose();
 		}
-	},
-	setup(__props) {
-		const arrayField = useNotArrayField(__props);
-		return (_ctx, _cache) => {
-			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(arrayField))));
-		};
+		return node.instance;
 	}
-});
-//#endregion
-//#region src/composables/use-not-field.ts
-/**
-* Field state, validation, and mutation helpers for `<NotField>`.
-* @template TSchema The form schema.
-* @internal
-* @param props Path and optional form and validation triggers.
-* @returns Slot state for `<NotField>`.
-*/
-function useNotField(props) {
-	const form = useNotFormInstance(props.form);
-	const errors = computed(() => form.getFieldErrors(props.path));
-	const isValid = computed(() => errors.value.length === 0);
-	const isTouched = computed(() => form.touchedFields.has(props.path));
-	const isDirty = computed(() => form.dirtyFields.has(props.path));
-	const isValidating = computed(() => form.validatingFields.has(props.path));
-	const validateOn = computed(() => ({
-		onBlur: true,
-		onChange: true,
-		...props.validateOn
-	}));
-	let debounceTimer;
-	/** Clears a pending debounce timer. */
-	function clearDebounce() {
-		if (debounceTimer === void 0) return;
-		clearTimeout(debounceTimer);
-		debounceTimer = void 0;
-	}
-	/** Runs field validation immediately, or after `debounce` ms. */
-	function scheduleValidation() {
-		if (!props.debounce) {
-			form.validateField(props.path);
-			return;
+	function arrayField(path, config) {
+		const key = `array:${path}`;
+		let node = nodes.get(key);
+		if (!node) {
+			node = createArrayField(host, {
+				config,
+				createScope: (getItemPath) => {
+					return createFieldScope(host, getItemPath);
+				},
+				getPath: () => {
+					return joinPath(getBasePath(), path);
+				}
+			});
+			nodes.set(key, node);
+			if (isDisposed) node.dispose();
 		}
-		clearDebounce();
-		debounceTimer = setTimeout(() => {
-			form.validateField(props.path);
-		}, props.debounce);
-	}
-	/** Marks touched and validates on blur when enabled. */
-	function onBlur() {
-		clearDebounce();
-		form.markFieldAsTouched(props.path);
-		if (validateOn.value?.onBlur) form.validateField(props.path);
+		return node.instance;
 	}
-	/** Syncs dirty and, in eager mode, revalidates on input while invalid. */
-	function onInput() {
-		form.syncDirtyState(props.path);
-		if (!validateOn.value?.onInput) return;
-		if (props.validationMode === "eager" && !isValid.value) scheduleValidation();
+	function dispose() {
+		isDisposed = true;
+		for (const node of nodes.values()) node.dispose();
+		nodes.clear();
 	}
-	/** Syncs dirty and, in eager mode, revalidates on change while invalid. */
-	function onChange() {
-		form.syncDirtyState(props.path);
-		if (!validateOn.value?.onChange) return;
-		if (props.validationMode === "eager" && !isValid.value) scheduleValidation();
+	return {
+		arrayField,
+		dispose,
+		field
+	};
+}
+// src/factories/create-validation-run-registry.ts
+/**
+* Creates a tracker for validations that are currently running.
+*
+* Validation is async, so a second one can start before the first finishes.
+* The registry marks the older run stale, so its result is dropped instead of
+* overwriting fresher data.
+* @returns Functions to start a run, finish a run, and invalidate every run.
+* @remarks One registry per form.
+* @example
+* const run = runs.startRun('field', 'email')
+* // ... await validation ...
+* if (!run.isStale) {
+*   applyResult()
+* }
+* runs.finishRun(run)
+*/
+function createValidationRunRegistry() {
+	/** Id of the most recently started run. Only ever goes up. */
+	let latestRunId = 0;
+	/** Runs that started but have not finished, keyed by run id. */
+	const activeRuns = reactive(/* @__PURE__ */ new Map());
+	/**
+	* Registers a run and marks the older runs it replaces as stale.
+	*
+	* A run replaces another when its result would overwrite it (see `doesScopeCover`).
+	* A running submit is never replaced by a non-submit run: a field check or a
+	* manual `validate()` must not cancel a submit in progress.
+	* @param origin What started the run.
+	* @param path Dot-notation field path. Leave out for a whole-form run.
+	* @returns The new run. Check `run.isStale` after awaiting.
+	*/
+	function startRun(origin, path) {
+		const newRun = {
+			id: ++latestRunId,
+			isStale: false,
+			origin,
+			scope: getValidationScope(path)
+		};
+		for (const [activeRunId, activeRun] of activeRuns) {
+			if (origin !== "submit" && activeRun.origin === "submit" || !doesScopeCover(newRun.scope, activeRun.scope)) continue;
+			activeRun.isStale = true;
+			activeRuns.delete(activeRunId);
+		}
+		activeRuns.set(newRun.id, newRun);
+		return newRun;
 	}
 	/**
-	* Validates on mount when `validateOn.onMount` is set. This is the only
-	* trigger not exposed through `events` below, since there's no DOM event
-	* to bind — it runs on its own via the `onMounted` hook further down.
+	* Removes a run from the active list, whether it succeeded, failed or went stale. Safe to call twice.
+	* @param run The run returned by `startRun`.
 	*/
-	function onMount() {
-		if (validateOn.value?.onMount) form.validateField(props.path);
+	function finishRun(run) {
+		activeRuns.delete(run.id);
+	}
+	/** Marks every active run stale and empties the list (form reset, value change, schema change). */
+	function markAllRunsStale() {
+		for (const run of activeRuns.values()) run.isStale = true;
+		activeRuns.clear();
 	}
-	const events = {
-		onBlur,
-		onChange,
-		onInput
+	return {
+		activeRuns: readonly(activeRuns),
+		finishRun,
+		markAllRunsStale,
+		startRun
 	};
-	onMounted(async () => {
-		await nextTick();
-		onMount();
+}
+// src/factories/create-form.ts
+/**
+* Builds a complete reactive form: values, errors, validation, submit handling,
+* and the registry that gives every field a stable identity.
+*
+* Single source of truth:
+* - values live in `values`; fields only point at them by path;
+* - errors live in `errors` as the schema reports them (by path); array mutations re-point them;
+* - touched state lives in `touchedFields`, keyed by field id, so it survives reordering;
+* - pending debounced validations live in `fieldTasks`, keyed by field id.
+* @template TSchema - The schema describing the form's data (must be an object schema).
+* @param config Schema, starting values/errors, and the submit handler.
+* @returns The full reactive form.
+* @remarks Internal building block. Prefer the `useForm` composable.
+*/
+function createForm(config) {
+	const initialValues = shallowRef(klona(toRaw(config.initialValues ?? {})));
+	const initialErrors = shallowRef(klona(toRaw(config.initialErrors ?? [])));
+	/** Live form data (a separate copy of the initial values). */
+	const values = reactive(klona(initialValues.value));
+	/** Live validation errors (a separate copy of the initial errors). */
+	const errors = reactive(klona(initialErrors.value));
+	/** Ids of the fields that were blurred. */
+	const touchedFields = shallowReactive(/* @__PURE__ */ new Set());
+	/** Debounced validations waiting to fire, by field id. */
+	const fieldTasks = /* @__PURE__ */ new Map();
+	const isSubmitting = ref(false);
+	const submitCount = ref(0);
+	const resetCount = ref(0);
+	const isSubmitted = computed(() => {
+		return submitCount.value > 0;
 	});
-	onUnmounted(() => {
-		clearDebounce();
+	const isTouched = computed(() => {
+		return isSubmitted.value || touchedFields.size > 0;
 	});
-	return reactive({
-		errors,
-		events,
-		isDirty,
-		isTouched,
-		isValid,
-		isValidating,
-		path: computed(() => props.path)
+	const isDirty = computed(() => {
+		return !dequal(values, initialValues.value);
 	});
-}
-//#endregion
-//#region src/components/not-field.vue
-var not_field_default = /* @__PURE__ */ defineComponent({
-	__name: "not-field",
-	props: {
-		path: {
-			type: [String, Object],
-			required: true
-		},
-		form: {
-			type: Object,
-			required: false
-		},
-		validateOn: {
-			type: Object,
-			required: false,
-			default: void 0
-		},
-		validationMode: {
-			type: String,
-			required: false,
-			default: "eager"
-		},
-		debounce: {
-			type: Number,
-			required: false,
-			default: void 0
-		}
-	},
-	setup(__props) {
-		const field = useNotField(__props);
-		return (_ctx, _cache) => {
-			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(field))));
-		};
+	const isValid = computed(() => {
+		return errors.length === 0;
+	});
+	function touchField(id) {
+		touchedFields.add(id);
 	}
-});
-//#endregion
-//#region src/components/not-form.vue
-var not_form_default = /* @__PURE__ */ defineComponent({
-	inheritAttrs: false,
-	__name: "not-form",
-	props: { form: {
-		type: Object,
-		required: true
-	} },
-	setup(__props) {
-		provideNotFormInstance(__props.form);
-		return (_ctx, _cache) => {
-			return openBlock(), createElementBlock(Fragment, null, [createCommentVNode("\n    Reset is always prevented here, regardless of what (if anything) the\n    consumer binds to @reset, since a native reset would otherwise clear\n    every input before `values` has a chance to react to it.\n\n    Submit is NOT prevented here. `form.submit()` calls `event.preventDefault()`\n    itself when it runs, which only happens if the consumer binds @submit to it\n    (e.g. `@submit=\"form.submit\"`) — see the NotForm docs for why this matters.\n  "), createElementVNode("form", mergeProps(_ctx.$attrs, { onReset: _cache[0] || (_cache[0] = withModifiers(() => {}, ["prevent"])) }), [renderSlot(_ctx.$slots, "default")], 16)], 2112);
-		};
+	function untouchField(id) {
+		touchedFields.delete(id);
 	}
-});
-//#endregion
-//#region src/components/not-message.vue
-var not_message_default = /* @__PURE__ */ defineComponent({
-	inheritAttrs: false,
-	__name: "not-message",
-	props: {
-		as: {
-			type: null,
-			required: false,
-			default: "span"
-		},
-		path: {
-			type: [String, Object],
-			required: true
-		},
-		form: {
-			type: Object,
-			required: false
-		}
-	},
-	setup(__props) {
-		const props = __props;
-		const form = useNotFormInstance(props.form);
-		const message = computed(() => form.getFieldErrors(props.path)[0]?.message);
-		return (_ctx, _cache) => {
-			return message.value ? (openBlock(), createBlock(resolveDynamicComponent(__props.as), normalizeProps(mergeProps({ key: 0 }, _ctx.$attrs)), {
-				default: withCtx(() => [renderSlot(_ctx.$slots, "default", { message: message.value }, () => [createTextVNode(toDisplayString(message.value), 1)])]),
-				_: 3
-			}, 16)) : createCommentVNode("v-if", true);
-		};
+	function isFieldTouched(id) {
+		return isSubmitted.value || touchedFields.has(id);
 	}
-});
-//#endregion
-//#region src/utils/issues.ts
-/**
-* Whether two issue paths point at the same field after segment normalization.
-* @internal
-* @param issuePathA First path.
-* @param issuePathB Second path.
-* @returns `true` when both paths are defined, same length, and equal segment-wise.
-*/
-function areIssuePathsEqual(issuePathA, issuePathB) {
-	if (!issuePathA || !issuePathB) return false;
-	if (issuePathA.length !== issuePathB.length) return false;
-	return issuePathA.every((segment, segmentIndex) => areSegmentsEqual(segment, issuePathB[segmentIndex]));
-}
-//#endregion
-//#region src/factories/create-not-form-instance.ts
-/**
-* Builds the full reactive form instance used by `useNotForm` and field components.
-* @template TSchema The form schema.
-* @internal
-* @param config Schema, initial values/errors, and submit handler.
-* @returns Assembled {@linkcode NotFormInstance}.
-*/
-function createNotFormInstance(config) {
-	/** Baseline values for reset. */
-	const initialValues = klona(config.initialValues ?? {});
-	/** Live field values. */
-	const values = reactive(klona(initialValues));
-	/** Baseline issues for reset. */
-	const initialErrors = klona(config.initialErrors ?? []);
-	/** Current validation issues. */
-	const errors = reactive([...initialErrors]);
-	/** Paths the user has interacted with. */
-	const touchedFields = reactive(/* @__PURE__ */ new Set());
-	const isTouched = computed(() => touchedFields.size > 0);
-	/** Paths whose value differs from the baseline. */
-	const dirtyFields = reactive(/* @__PURE__ */ new Set());
-	const isDirty = computed(() => dirtyFields.size > 0);
-	/** Paths with an in-flight validation. */
-	const validatingFields = reactive(/* @__PURE__ */ new Set());
-	const isValid = computed(() => errors.length === 0);
-	const isValidating = computed(() => validatingFields.size > 0);
-	const isSubmitting = ref(false);
+	function cancelFieldTask(id) {
+		const timer = fieldTasks.get(id);
+		if (timer === void 0) return;
+		clearTimeout(timer);
+		fieldTasks.delete(id);
+	}
+	function cancelAllFieldTasks() {
+		for (const timer of fieldTasks.values()) clearTimeout(timer);
+		fieldTasks.clear();
+	}
+	function scheduleFieldTask(id, delay, task) {
+		cancelFieldTask(id);
+		fieldTasks.set(id, setTimeout(() => {
+			fieldTasks.delete(id);
+			task();
+		}, delay));
+	}
+	/** Tracks running validations so outdated results can be discarded. */
+	const validationRuns = createValidationRunRegistry();
 	/**
-	* Bumped by validate, submit, and reset. Older in-flight runs are discarded:
-	* each still resolves with its own result, but only the run matching the
-	* current generation when it finishes gets to write to `errors`.
+	* Increases every time a submit starts. A submit loop keeps going only while its own
+	* attempt id is still the latest, so bumping this elsewhere cancels the submit in progress.
 	*/
-	let generation = 0;
-	/** Latest per-field validation cycle id, used to drop stale field results. */
-	const fieldValidationCycleMap = /* @__PURE__ */ new Map();
-	/** Active validation count per path so overlapping runs do not clear too early. */
-	const validatingFieldCounts = /* @__PURE__ */ new Map();
+	let latestSubmitAttemptId = 0;
+	const isValidating = computed(() => {
+		return validationRuns.activeRuns.size > 0;
+	});
 	/**
-	* Runs the current schema against `values`. Resolves `config.schema`
-	* first via `toValue`, so a ref or a getter function works the same as
-	* passing the schema directly.
-	* @returns Standard Schema result.
+	* Validates a snapshot of the current values against the schema.
+	* @returns The schema result (`{ value }` or `{ issues }`), sync or async.
 	*/
-	function executeSchemaValidation() {
-		return toValue(config.schema)["~standard"].validate(values);
+	function validateAgainstSchema() {
+		const schema = toValue(config.schema);
+		const valuesSnapshot = klona(toRaw(values));
+		return schema["~standard"].validate(valuesSnapshot);
 	}
 	/**
-	* Sets a field value and syncs its dirty flag. Does not validate.
-	* @template TPath Field path.
-	* @param path Dot path.
-	* @param value Value to assign.
+	* Runs one validation and reports whether it was replaced meanwhile.
+	* Never throws: a crashing schema becomes a normal issue.
+	* @param origin What started this validation.
+	* @param path Dot-notation field path. Leave out for a whole-form run.
+	* @returns The schema result and whether it went stale.
 	*/
-	function setValue(path, value) {
-		setProperty(values, path, value);
-		syncDirtyState(path);
+	async function runValidation(origin, path) {
+		const run = validationRuns.startRun(origin, path);
+		try {
+			let result;
+			try {
+				result = await validateAgainstSchema();
+			} catch (error) {
+				result = { issues: [createValidationIssueFromError(error, path)] };
+			}
+			return {
+				isStale: run.isStale,
+				result
+			};
+		} finally {
+			validationRuns.finishRun(run);
+		}
 	}
-	/**
-	* Upserts an issue at the same path, or appends it.
-	* @param error Issue to set.
-	*/
-	function setError(error) {
-		const existingIndex = errors.findIndex((existing) => areIssuePathsEqual(existing.path, error.path));
-		if (existingIndex === -1) errors.push(error);
-		else errors[existingIndex] = error;
+	watch(() => {
+		return toValue(config.schema);
+	}, () => {
+		validationRuns.markAllRunsStale();
+	}, { flush: "sync" });
+	watch(values, () => {
+		validationRuns.markAllRunsStale();
+	}, {
+		deep: true,
+		flush: "sync"
+	});
+	function getValue(path) {
+		return getValueAtPath(values, path);
+	}
+	function setValue(path, value) {
+		setValueAtPath(values, path, value);
 	}
-	/**
-	* Replaces the entire error list.
-	* @internal
-	* @param nextErrors Replacement issues.
-	*/
 	function replaceErrors(nextErrors) {
 		errors.splice(0, errors.length, ...nextErrors);
 	}
-	/**
-	* Removes every issue.
-	* @internal
-	*/
 	function clearErrors() {
 		errors.length = 0;
 	}
-	/**
-	* Issues whose path exactly equals `path` — see the same note on
-	* {@linkcode NotFormInstance.getFieldErrors}.
-	* @param path Dot path.
-	* @returns Matching issues.
-	*/
 	function getFieldErrors(path) {
-		const targetPath = parsePath(path);
-		return errors.filter((error) => areIssuePathsEqual(error.path, targetPath));
-	}
-	/**
-	* Forces a field dirty.
-	* @internal
-	* @param path Dot path.
-	*/
-	function markFieldAsDirty(path) {
-		dirtyFields.add(path);
-	}
-	/**
-	* Forces every current leaf field dirty. Only paths present in `values`
-	* right now are affected — see the note on
-	* {@linkcode NotFormInstance.markAllFieldsAsTouched}.
-	* @internal
-	*/
-	function markAllFieldsAsDirty() {
-		for (const path of deepKeys(values)) dirtyFields.add(path);
-	}
-	/**
-	* Clears dirty state for one field.
-	* @internal
-	* @param path Dot path.
-	*/
-	function unmarkFieldAsDirty(path) {
-		dirtyFields.delete(path);
-	}
-	/**
-	* Clears dirty state for all fields.
-	* @internal
-	*/
-	function unmarkAllFieldsAsDirty() {
-		dirtyFields.clear();
-	}
-	/**
-	* Sets dirty from a deep compare against the baseline.
-	* @internal
-	* @param path Dot path.
-	*/
-	function syncDirtyState(path) {
-		const currentValue = getProperty(values, path);
-		const baselineValue = getProperty(initialValues, path);
-		if (dequal(currentValue, baselineValue)) unmarkFieldAsDirty(path);
-		else markFieldAsDirty(path);
-	}
-	/**
-	* Recalculates dirty state for every current leaf path.
-	* @internal
-	*/
-	function syncAllDirtyStates() {
-		for (const path of deepKeys(values)) syncDirtyState(path);
-	}
-	/**
-	* Marks a field as touched.
-	* @internal
-	* @param path Dot path.
-	*/
-	function markFieldAsTouched(path) {
-		touchedFields.add(path);
-	}
-	/**
-	* Marks every current leaf field as touched. Only paths present in
-	* `values` right now are affected — see the note on
-	* {@linkcode NotFormInstance.markAllFieldsAsTouched}.
-	* @internal
-	*/
-	function markAllFieldsAsTouched() {
-		for (const path of deepKeys(values)) touchedFields.add(path);
+		const targetPath = splitPath(path);
+		return errors.filter((error) => {
+			return isSamePath(error.path, targetPath);
+		});
 	}
 	/**
-	* Clears touched state for one field.
-	* @internal
-	* @param path Dot path.
+	* Replaces the errors sitting exactly at a path. Leaves the other errors alone.
+	* @param segments The path whose errors are replaced.
+	* @param nextIssues The new errors for that path.
 	*/
-	function unmarkFieldAsTouched(path) {
-		touchedFields.delete(path);
+	function replaceErrorsAt(segments, nextIssues) {
+		const keptErrors = errors.filter((error) => {
+			return !isSamePath(error.path, segments);
+		});
+		if (keptErrors.length === errors.length && nextIssues.length === 0) return;
+		replaceErrors([...keptErrors, ...nextIssues]);
 	}
-	/**
-	* Clears touched state for all fields.
-	* @internal
-	*/
-	function unmarkAllFieldsAsTouched() {
-		touchedFields.clear();
+	function setError(error) {
+		if (error.path) replaceErrorsAt(error.path, [error]);
+		else errors.push(error);
 	}
 	/**
-	* Increments the in-flight validation count for each path.
-	* @internal
-	* @param paths Field paths.
+	* Re-points the errors inside an array after it was mutated, so each error stays with its item.
+	* @param arrayPath Path of the mutated array.
+	* @param mapIndex Translates an item's old index to its new one (`undefined` drops the error).
 	*/
-	function markFieldsAsValidating(paths) {
-		for (const path of paths) {
-			validatingFieldCounts.set(path, (validatingFieldCounts.get(path) ?? 0) + 1);
-			validatingFields.add(path);
+	function remapArrayErrors(arrayPath, mapIndex) {
+		const arraySegments = splitPath(arrayPath);
+		const remappedErrors = [];
+		let hasChanged = false;
+		for (const error of errors) {
+			const remapped = remapIssueIndex(error, arraySegments, mapIndex);
+			if (remapped !== error) hasChanged = true;
+			if (remapped) remappedErrors.push(remapped);
 		}
+		if (hasChanged) replaceErrors(remappedErrors);
+	}
+	function isFieldValidating(path) {
+		const fieldSegments = splitPath(path);
+		for (const activeRun of validationRuns.activeRuns.values()) if (isFieldAffectedByScope(activeRun.scope, fieldSegments)) return true;
+		return false;
 	}
 	/**
-	* Decrements in-flight counts and clears a path when the count hits zero.
-	* @internal
-	* @param paths Field paths.
+	* Validates a single field and updates only that field's errors.
+	* The whole form is checked against the schema, but only issues sitting exactly at `path` are kept.
+	* @param path Dot-notation path to the field.
+	* @returns `{ issues }` if the field is invalid, otherwise `{ value }` with its current input value.
+	* A result made obsolete by a newer run is returned, but the errors are left untouched.
 	*/
-	function unmarkFieldsAsValidating(paths) {
-		for (const path of paths) {
-			const nextCount = (validatingFieldCounts.get(path) ?? 0) - 1;
-			if (nextCount <= 0) {
-				validatingFieldCounts.delete(path);
-				validatingFields.delete(path);
-			} else validatingFieldCounts.set(path, nextCount);
-		}
+	async function validateField(path) {
+		const { isStale, result } = await runValidation("field", path);
+		const fieldSegments = splitPath(path);
+		const fieldIssues = (result.issues ?? []).filter((issue) => {
+			return isSamePath(issue.path, fieldSegments);
+		});
+		if (!isStale) replaceErrorsAt(fieldSegments, fieldIssues);
+		return fieldIssues.length > 0 ? { issues: fieldIssues } : { value: getValue(path) };
 	}
 	/**
-	* Validates the whole form, replacing all errors. Bumps `generation`; see
-	* {@linkcode NotFormInstance.validate} for the concurrency guarantee this gives.
-	* @returns Standard Schema result.
+	* Validates the whole form and replaces all errors with the outcome.
+	* @returns The schema result. If a newer validation replaced this one, errors are left untouched.
 	*/
 	async function validate() {
-		const cycle = ++generation;
-		const paths = [...deepKeys(values)];
-		markFieldsAsValidating(paths);
-		try {
-			const result = await executeSchemaValidation();
-			if (cycle !== generation) return result;
-			if (result.issues) {
-				const issues = [...result.issues];
-				replaceErrors(issues);
-				return { issues };
-			}
-			clearErrors();
-			return { value: result.value };
-		} finally {
-			unmarkFieldsAsValidating(paths);
-		}
+		const { isStale, result } = await runValidation("form");
+		if (!isStale) replaceErrors(result.issues ? [...result.issues] : []);
+		return result;
 	}
 	/**
-	* Validates the form and writes issues only for `path`. `path` can be any
-	* granularity — see {@linkcode NotFormInstance.validateField}.
+	* Validates the whole form and, if valid, calls `config.onSubmit` with the parsed data.
 	*
-	* Dropped if a newer call for the same path or a newer whole-form generation starts.
-	* @param path Dot path.
-	* @returns Standard Schema result.
-	*/
-	async function validateField(path) {
-		const cycle = (fieldValidationCycleMap.get(path) ?? 0) + 1;
-		fieldValidationCycleMap.set(path, cycle);
-		const startGeneration = generation;
-		markFieldsAsValidating([path]);
-		try {
-			const result = await executeSchemaValidation();
-			if (generation !== startGeneration || fieldValidationCycleMap.get(path) !== cycle) return result;
-			const targetPath = parsePath(path);
-			for (let errorIndex = errors.length - 1; errorIndex >= 0; errorIndex--) if (areIssuePathsEqual(errors[errorIndex].path, targetPath)) errors.splice(errorIndex, 1);
-			const fieldIssues = (result.issues ?? []).filter((issue) => areIssuePathsEqual(issue.path, targetPath));
-			errors.push(...fieldIssues);
-			if (fieldIssues.length > 0) return { issues: fieldIssues };
-			return { value: getProperty(values, path) };
-		} finally {
-			unmarkFieldsAsValidating([path]);
-		}
-	}
-	/**
-	* Touches all fields, validates, then runs `onSubmit` when valid.
-	* @param event Optional submit event. `event.preventDefault()` is called
-	* immediately if `event` is given, before checking whether a submission
-	* is already in flight or whether validation passes.
+	* - Ignored while a submit is already running.
+	* - If validation is replaced mid-flight (the user kept typing), it is simply run again.
+	* - On failure, errors are shown and `onSubmit` is not called.
+	* @param event Browser submit event; its default page reload is prevented.
+	* @throws Whatever `config.onSubmit` throws (after `isSubmitting` has been reset).
 	*/
 	async function submit(event) {
 		event?.preventDefault();
 		if (isSubmitting.value) return;
-		markAllFieldsAsTouched();
-		syncAllDirtyStates();
-		const cycle = ++generation;
-		const paths = [...deepKeys(values)];
-		markFieldsAsValidating(paths);
 		isSubmitting.value = true;
+		submitCount.value++;
+		const thisSubmitAttemptId = ++latestSubmitAttemptId;
 		try {
-			const result = await executeSchemaValidation();
-			if (cycle !== generation) return;
-			if (result.issues) {
-				replaceErrors([...result.issues]);
+			while (thisSubmitAttemptId === latestSubmitAttemptId) {
+				const { isStale, result } = await runValidation("submit");
+				if (thisSubmitAttemptId !== latestSubmitAttemptId) return;
+				if (isStale) continue;
+				if (result.issues) {
+					replaceErrors([...result.issues]);
+					return;
+				}
+				clearErrors();
+				await config.onSubmit?.(result.value);
 				return;
 			}
-			clearErrors();
-			await config.onSubmit?.(result.value);
 		} finally {
-			unmarkFieldsAsValidating(paths);
-			isSubmitting.value = false;
+			if (thisSubmitAttemptId === latestSubmitAttemptId) isSubmitting.value = false;
 		}
 	}
-	/**
-	* Restores values and errors to the baseline. Optional arguments become
-	* the new baseline and fully replace the previous one — see
-	* {@linkcode NotFormInstance.reset} for the "replace, not merge" detail.
-	* @param nextValues New baseline values.
-	* @param nextErrors New baseline issues.
-	*/
 	function reset(nextValues, nextErrors) {
-		generation++;
-		fieldValidationCycleMap.clear();
-		validatingFieldCounts.clear();
-		validatingFields.clear();
-		if (nextValues) {
-			const freshValues = klona(nextValues);
-			for (const key of Object.keys(initialValues)) deleteProperty(initialValues, key);
-			Object.assign(initialValues, freshValues);
-		}
-		if (nextErrors) initialErrors.splice(0, initialErrors.length, ...klona(nextErrors));
-		for (const key of Object.keys(values)) deleteProperty(values, key);
-		Object.assign(values, klona(initialValues));
-		replaceErrors(klona(initialErrors));
-		unmarkAllFieldsAsTouched();
-		unmarkAllFieldsAsDirty();
+		const freshValues = isEvent(nextValues) ? void 0 : nextValues;
+		validationRuns.markAllRunsStale();
+		cancelAllFieldTasks();
+		latestSubmitAttemptId++;
+		isSubmitting.value = false;
+		if (freshValues !== void 0) initialValues.value = klona(toRaw(freshValues));
+		if (nextErrors !== void 0) initialErrors.value = klona(toRaw(nextErrors));
+		replaceRecordContents(values, klona(initialValues.value));
+		replaceErrors(klona(initialErrors.value));
+		touchedFields.clear();
+		submitCount.value = 0;
+		resetCount.value++;
 	}
+	/** The root scope: `form.field(path)` and `form.arrayField(path)` live here. */
+	const rootScope = createFieldScope({
+		cancelFieldTask,
+		getFieldErrors,
+		getInitialValue: (path) => {
+			return getValueAtPath(initialValues.value, path);
+		},
+		getResetCount: () => {
+			return resetCount.value;
+		},
+		getValue,
+		isFieldTouched,
+		isFieldValidating,
+		remapArrayErrors,
+		scheduleFieldTask,
+		setValue,
+		touchField,
+		untouchField,
+		validateField
+	}, () => {
+		return "";
+	});
+	if (getCurrentScope()) onScopeDispose(() => {
+		validationRuns.markAllRunsStale();
+		cancelAllFieldTasks();
+		rootScope.dispose();
+	});
 	return reactive({
+		arrayField: rootScope.arrayField,
 		clearErrors,
-		dirtyFields,
 		errors,
+		field: rootScope.field,
 		getFieldErrors,
+		getValue,
+		initialErrors,
+		initialValues,
 		isDirty,
+		isFieldValidating,
+		isSubmitted,
 		isSubmitting,
 		isTouched,
 		isValid,
 		isValidating,
-		markAllFieldsAsDirty,
-		markAllFieldsAsTouched,
-		markFieldAsDirty,
-		markFieldAsTouched,
 		replaceErrors,
 		reset,
+		resetCount,
 		setError,
 		setValue,
 		submit,
-		syncAllDirtyStates,
-		syncDirtyState,
-		touchedFields,
-		unmarkAllFieldsAsDirty,
-		unmarkAllFieldsAsTouched,
-		unmarkFieldAsDirty,
-		unmarkFieldAsTouched,
+		submitCount,
 		validate,
 		validateField,
-		validatingFields,
 		values
 	});
 }
-//#endregion
-//#region src/composables/use-not-form.ts
 /**
-* Creates a form instance and returns the public {@linkcode NotFormAPI}.
-* @template TSchema The form schema.
-* @param config Schema, initial values/errors, and submit handler.
-* @returns Public form API. Child components still inject the full instance via `<NotForm>`.
+* Tells an event apart from starting values.
+* @param value The first argument given to `reset`.
+* @returns `true` if it is a DOM event.
+*/
+function isEvent(value) {
+	return typeof Event !== "undefined" && value instanceof Event;
+}
+/**
+* Empties a reactive record and refills it, keeping the same object identity.
+* @param target The record to replace the contents of.
+* @param source The new contents.
+*/
+function replaceRecordContents(target, source) {
+	for (const key of Object.keys(target)) delete target[key];
+	Object.assign(target, source);
+}
+// src/composables/use-form.ts
+/**
+* Creates a reactive, schema-validated form. Call it inside `setup()`, so its
+* watchers and pending timers are cleaned up when the component unmounts.
+* @template TSchema - A Standard Schema (Zod, Valibot, ArkType, ...) describing the form's data. Must be an object schema.
+* @param config The schema, optional starting values/errors, and an optional submit handler.
+* @returns The form. Pass it to `<Form :form />` and use `form.field(path)` / `form.arrayField(path)` to create fields.
+* @example
+* ```vue
+* <script setup lang="ts">
+* import { z } from 'zod'
+* import { Field, Form, useForm } from 'notform'
+*
+* const form = useForm({
+*   schema: z.object({ email: z.email() }),
+*   initialValues: { email: '' },
+*   onSubmit: async (data) => {
+*     await api.signUp(data) // `data` is the validated output
+*   },
+* })
+* <\/script>
+*
+* <template>
+*   <Form :form>
+*     <Field v-slot="{ field }" :field="form.field('email')">
+*       <input v-model="field.model" v-bind="field.events" type="email">
+*     </Field>
+*     <button type="submit" :disabled="form.isSubmitting">Sign up</button>
+*   </Form>
+* </template>
+* ```
 */
-function useNotForm(config) {
-	return createNotFormInstance(config);
+function useForm(config) {
+	return createForm(config);
 }
-//#endregion
-export { not_array_field_default as NotArrayField, not_field_default as NotField, not_form_default as NotForm, not_message_default as NotMessage, useNotForm };
+export { array_field_default as ArrayField, field_default as Field, field_error_default as FieldError, form_default as Form, useForm };