attaform 0.18.2 → 0.19.0

package/dist/shared/{attaform.CZ-XtZt_.mjs → attaform.BTi-PsHr.mjs}

@@ -1,5 +1,5 @@
 import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, reactive, watch, markRaw, toRaw, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, effectScope, nextTick } from 'vue';
-import { i as canonicalizePath, H as segmentsForPathKey, t as isPathPrefix, b as FORM_ERRORS_PATH_KEY, _ as __DEV__, E as pathKeyToDotted, g as SubmitErrorHandlerError, A as AnonPersistError, j as captureUserCallSite, R as ROOT_PATH, q as enforceSensitiveCheck, F as FORM_ERRORS_PATH, k as coerceToPathKey, G as segmentMatchesSensitive, v as isSensitivePath, n as createPersistOptInRegistry, c as InvalidUseFormConfigError, r as ensureAttaformInstalled, K as useRegistry, z as kFormContext, B as kFormInstanceId, f as ReservedFormKeyError, m as createIsSensitivePath, p as createSegmentMatchesSensitive, y as kAttaformWizardActiveStepResolver, w as kAttaformAncestorWizard } from './attaform.CDmaxrt2.mjs';
+import { _ as __DEV__, i as canonicalizePath, H as segmentsForPathKey, t as isPathPrefix, b as FORM_ERRORS_PATH_KEY, E as pathKeyToDotted, g as SubmitErrorHandlerError, A as AnonPersistError, j as captureUserCallSite, d as ROOT_PATH_KEY, R as ROOT_PATH, q as enforceSensitiveCheck, F as FORM_ERRORS_PATH, k as coerceToPathKey, G as segmentMatchesSensitive, v as isSensitivePath, n as createPersistOptInRegistry, c as InvalidUseFormConfigError, r as ensureAttaformInstalled, K as useRegistry, z as kFormContext, B as kFormInstanceId, f as ReservedFormKeyError, m as createIsSensitivePath, p as createSegmentMatchesSensitive, y as kAttaformWizardActiveStepResolver, w as kAttaformAncestorWizard } from './attaform.CrpjyXdO.mjs';
 
 const NOT_FOUND = Symbol("NOT_FOUND");
 function descendStep(value, segment) {
@@ -434,6 +434,74 @@ function structuralSnapshot(value) {
   return out;
 }
 
+const defaultDisplayState = (field, formMeta) => {
+  const gateOpen = formMeta.submissionAttempts > 0 || field.blurredAfterInteraction === true;
+  if (!gateOpen) return "idle";
+  if (field.validating === true) return "pending";
+  const hasOwnError = field.errors.some(
+    (e) => e.path.length === field.path.length && e.path.every((s, i) => s === field.path[i])
+  );
+  if (hasOwnError) return "error";
+  if (field.valid === true && field.blank !== true && field.dirty === true) return "success";
+  return "idle";
+};
+function resolveGetDisplayState(config) {
+  return config ?? defaultDisplayState;
+}
+
+const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
+const DEFAULT_PERSISTENCE_DEBOUNCE_MS = 300;
+const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
+const PERSISTENCE_KEY_PREFIX = "attaform:";
+const RESERVED_KEY_PREFIX = "__atta:";
+const ANONYMOUS_FORM_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon:`;
+const ANONYMOUS_WIZARD_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon-wizard:`;
+const DEFAULT_MAX_RECURSION_DEPTH = 64;
+function normalizeNumericOption(config) {
+  const { value, source, allowInfinity, min, defaultValue } = config;
+  if (allowInfinity && value === Infinity) return Infinity;
+  if (typeof value !== "number" || Number.isNaN(value) || value === Infinity || value === -Infinity) {
+    if (__DEV__) {
+      const acceptedDescription = allowInfinity ? "a non-negative integer or Infinity" : "a non-negative finite integer";
+      console.warn(
+        `[attaform] ${source} must be ${acceptedDescription}; got ${String(value)}. Falling back to ${String(defaultValue)}.`
+      );
+    }
+    return defaultValue;
+  }
+  return Math.max(min, Math.floor(value));
+}
+
+function hashStableString(input, seed = 0) {
+  let h1 = 3735928559 ^ seed;
+  let h2 = 1103547991 ^ seed;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36).padStart(11, "0");
+}
+
+const ANON_STEM = "atta";
+function readableFormKeyStem(formKey) {
+  if (formKey === "" || formKey.startsWith(ANONYMOUS_FORM_KEY_PREFIX)) return ANON_STEM;
+  const sanitized = formKey.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized === "" ? ANON_STEM : sanitized;
+}
+function fieldIdToken(formInstanceId, pathKey) {
+  return hashStableString(`${formInstanceId}:${pathKey}`).slice(-7);
+}
+function computeFieldIdentity(formInstanceId, formKey, pathKey) {
+  const id = `${readableFormKeyStem(formKey)}-${fieldIdToken(formInstanceId, pathKey)}`;
+  return {
+    id,
+    aria: Object.freeze({ errorId: `${id}-error`, descriptionId: `${id}-description` })
+  };
+}
+
 const EMPTY_RESOLVED_FIELD_META = Object.freeze({
   label: "",
   description: void 0,
@@ -467,21 +535,21 @@ function isUnderStubAncestor(state, segments) {
   }
   return false;
 }
-function buildFieldStateAccessor(state, getFormMetaBase, options) {
+function buildFieldStateAccessor(state, formInstanceId, getFormMetaBase, options) {
   const cache = /* @__PURE__ */ new Map();
-  const predicate = options?.shouldShowErrors;
+  const predicate = options?.getDisplayState;
   return function getFieldState(pathInput) {
     const { segments, key } = canonicalizePath(pathInput);
     const cached = cache.get(key);
     if (cached !== void 0) return cached;
     const c = computed(
-      () => state.schema.isLeafAtPath(segments) ? buildLeafFieldState(state, segments, key, getFormMetaBase, predicate) : buildContainerFieldState(state, segments, key, getFormMetaBase, predicate)
+      () => state.schema.isLeafAtPath(segments) ? buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBase, predicate) : buildContainerFieldState(state, segments, key, formInstanceId, getFormMetaBase, predicate)
     );
     cache.set(key, c);
     return c;
   };
 }
-function buildLeafFieldStateBase(state, segments, key) {
+function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
   const record = state.fields.get(key);
   const value = state.getValueAtPath(segments);
   const original = state.originals.get(key)?.value;
@@ -511,6 +579,8 @@ function buildLeafFieldStateBase(state, segments, key) {
     focused: record?.focused ?? null,
     blurred: record?.blurred ?? null,
     touched: record?.touched ?? false,
+    interacted: record?.interacted ?? false,
+    blurredAfterInteraction: record?.blurredAfterInteraction ?? false,
     connected: record?.connected ?? false,
     element: firstElement,
     elements: elementsArr,
@@ -519,6 +589,8 @@ function buildLeafFieldStateBase(state, segments, key) {
     validating,
     valid,
     path: segments,
+    ...computeFieldIdentity(formInstanceId, state.formKey, key),
+    key: state.arrayElementKey(segments),
     blank: state.blankPaths.has(key),
     label,
     description: resolved.description,
@@ -526,11 +598,11 @@ function buildLeafFieldStateBase(state, segments, key) {
     meta: resolved.meta
   };
 }
-function buildLeafFieldState(state, segments, key, getFormMetaBase, shouldShowErrors) {
-  const base = buildLeafFieldStateBase(state, segments, key);
-  return decorateWithDerivedProps(base, state, getFormMetaBase, shouldShowErrors);
+function buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBase, getDisplayState) {
+  const base = buildLeafFieldStateBase(state, segments, key, formInstanceId);
+  return decorateWithDerivedProps(base, state, getFormMetaBase, getDisplayState);
 }
-function buildContainerFieldStateBase(state, segments, _key) {
+function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   const formValue = state.form.value;
   const value = state.getValueAtPath(segments);
   const original = state.originals.get(canonicalizePath(segments).key)?.value;
@@ -540,6 +612,8 @@ function buildContainerFieldStateBase(state, segments, _key) {
   let focused = false;
   let blurred = false;
   let touched = false;
+  let interacted = false;
+  let blurredAfterInteraction = false;
   let connected = false;
   let validating = false;
   let updatedAt = null;
@@ -558,6 +632,8 @@ function buildContainerFieldStateBase(state, segments, _key) {
     if (leafRecord?.focused === true) focused = true;
     if (leafRecord?.blurred === true) blurred = true;
     if (leafRecord?.touched === true) touched = true;
+    if (leafRecord?.interacted === true) interacted = true;
+    if (leafRecord?.blurredAfterInteraction === true) blurredAfterInteraction = true;
     if (leafRecord?.connected === true) connected = true;
     if ((state.fieldValidationCounts.get(leafKey) ?? 0) > 0) validating = true;
     if (state.pathHasAsyncValidation(entry.segments)) asyncPending = true;
@@ -566,6 +642,10 @@ function buildContainerFieldStateBase(state, segments, _key) {
       if (updatedAt === null || ts > updatedAt) updatedAt = ts;
     }
   }
+  if (!dirty && state.hasStructuralChangeUnder(segments)) {
+    pristine = false;
+    dirty = true;
+  }
   const errors = aggregateErrorsAt(state, segments);
   if (!asyncPending && state.pathHasAsyncValidation(segments)) asyncPending = true;
   const gated = asyncPending && !state.firstValidationDone.value;
@@ -581,6 +661,8 @@ function buildContainerFieldStateBase(state, segments, _key) {
     focused,
     blurred,
     touched,
+    interacted,
+    blurredAfterInteraction,
     connected,
     element: null,
     elements: EMPTY_ELEMENTS,
@@ -589,6 +671,8 @@ function buildContainerFieldStateBase(state, segments, _key) {
     validating,
     valid,
     path: segments,
+    ...computeFieldIdentity(formInstanceId, state.formKey, key),
+    key: state.arrayElementKey(segments),
     blank,
     label,
     description: resolved.description,
@@ -596,15 +680,29 @@ function buildContainerFieldStateBase(state, segments, _key) {
     meta: resolved.meta
   };
 }
-function buildContainerFieldState(state, segments, key, getFormMetaBase, shouldShowErrors) {
-  const base = buildContainerFieldStateBase(state, segments);
-  return decorateWithDerivedProps(base, state, getFormMetaBase, shouldShowErrors);
+function buildContainerFieldState(state, segments, key, formInstanceId, getFormMetaBase, getDisplayState) {
+  const base = buildContainerFieldStateBase(state, segments, key, formInstanceId);
+  return decorateWithDerivedProps(base, state, getFormMetaBase, getDisplayState);
 }
-function decorateWithDerivedProps(base, state, getFormMetaBase, shouldShowErrors) {
+function decorateWithDerivedProps(base, state, getFormMetaBase, getDisplayState) {
   const firstError = base.errors[0];
-  const predicate = shouldShowErrors ?? state.shouldShowErrors;
-  const showErrors = base.errors.length > 0 && predicate(base, getFormMetaBase());
-  return { ...base, showErrors, firstError };
+  const predicate = getDisplayState ?? state.getDisplayState;
+  const formMeta = getFormMetaBase();
+  let displayState;
+  try {
+    displayState = predicate(base, formMeta);
+  } catch {
+    displayState = defaultDisplayState(base, formMeta);
+  }
+  return {
+    ...base,
+    displayState,
+    showErrors: displayState === "error",
+    showPending: displayState === "pending",
+    showSuccess: displayState === "success",
+    showIdle: displayState === "idle",
+    firstError
+  };
 }
 function aggregateErrorsAt(state, prefix) {
   const formValue = state.form.value;
@@ -986,19 +1084,19 @@ function buildFieldArrayApi(state) {
     prepend(path, value) {
       const next = readArray(path);
       next.unshift(value);
-      return writeArray(path, next, { kind: "shift-from", index: 0 });
+      return writeArray(path, next, { kind: "insert", index: 0 });
     },
     insert(path, index, value) {
       const next = readArray(path);
       next.splice(index, 0, value);
       const clampedIndex = Math.max(0, Math.min(index, next.length));
-      return writeArray(path, next, { kind: "shift-from", index: clampedIndex });
+      return writeArray(path, next, { kind: "insert", index: clampedIndex });
     },
     remove(path, index) {
       const next = readArray(path);
       if (index < 0 || index >= next.length) return false;
       next.splice(index, 1);
-      return writeArray(path, next, { kind: "shift-from", index });
+      return writeArray(path, next, { kind: "remove", index });
     },
     swap(path, a, b) {
       const next = readArray(path);
@@ -1016,11 +1114,7 @@ function buildFieldArrayApi(state) {
       const [item] = next.splice(from, 1);
       const clampedTo = Math.max(0, Math.min(to, next.length));
       next.splice(clampedTo, 0, item);
-      return writeArray(path, next, {
-        kind: "shift-range",
-        fromIndex: Math.min(from, clampedTo),
-        toIndex: Math.max(from, clampedTo)
-      });
+      return writeArray(path, next, { kind: "move", from, to: clampedTo });
     },
     replace(path, index, value) {
       const next = readArray(path);
@@ -1039,6 +1133,8 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "focused",
   "blurred",
   "touched",
+  "interacted",
+  "blurredAfterInteraction",
   "connected",
   "element",
   "elements",
@@ -1046,20 +1142,28 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "errors",
   "validating",
   "valid",
+  "displayState",
   "showErrors",
+  "showPending",
+  "showSuccess",
+  "showIdle",
   "firstError",
   "path",
+  "id",
+  "aria",
+  "key",
   "blank",
   "label",
   "description",
   "placeholder",
   "meta"
 ]);
-function buildFieldStateProxy(state, getFormMetaBase, options) {
+function buildFieldStateProxy(state, formInstanceId, getFormMetaBase, options) {
   const getFieldStateAt = buildFieldStateAccessor(
     state,
+    formInstanceId,
     getFormMetaBase,
-    options?.shouldShowErrors !== void 0 ? { shouldShowErrors: options.shouldShowErrors } : void 0
+    options?.getDisplayState !== void 0 ? { getDisplayState: options.getDisplayState } : void 0
   );
   const snapshotFieldStateAt = (path) => {
     const view = getFieldStateAt(path).value;
@@ -1166,29 +1270,6 @@ function walk$2(value, basePath, schema, snapshotFieldStateAt) {
   return result;
 }
 
-const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
-const DEFAULT_PERSISTENCE_DEBOUNCE_MS = 300;
-const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
-const PERSISTENCE_KEY_PREFIX = "attaform:";
-const RESERVED_KEY_PREFIX = "__atta:";
-const ANONYMOUS_FORM_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon:`;
-const ANONYMOUS_WIZARD_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon-wizard:`;
-const DEFAULT_MAX_RECURSION_DEPTH = 64;
-function normalizeNumericOption(config) {
-  const { value, source, allowInfinity, min, defaultValue } = config;
-  if (allowInfinity && value === Infinity) return Infinity;
-  if (typeof value !== "number" || Number.isNaN(value) || value === Infinity || value === -Infinity) {
-    if (__DEV__) {
-      const acceptedDescription = allowInfinity ? "a non-negative integer or Infinity" : "a non-negative finite integer";
-      console.warn(
-        `[attaform] ${source} must be ${acceptedDescription}; got ${String(value)}. Falling back to ${String(defaultValue)}.`
-      );
-    }
-    return defaultValue;
-  }
-  return Math.max(min, Math.floor(value));
-}
-
 const PERSISTENCE_MODULE_KEY = "persistence";
 async function getStorageAdapter(storage) {
   if (typeof storage === "object") return storage;
@@ -1994,6 +2075,8 @@ function detachFocusListeners(element) {
 function buildRegister(state, formInstanceId, instanceConfig) {
   const coerceIndex = instanceConfig?.coerce !== void 0 ? resolveCoercionIndex(instanceConfig.coerce) : state.coerceIndex;
   const instanceMeta = instanceConfig?.instanceMeta;
+  const formAutoAria = instanceConfig?.autoAria ?? true;
+  const getDisplayStateAt = instanceConfig?.getDisplayStateAt;
   const withInstanceMeta = (meta) => {
     if (instanceMeta === void 0) return meta;
     return meta === void 0 ? { instance: instanceMeta } : { ...meta, instance: instanceMeta };
@@ -2048,6 +2131,10 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         callSite: captureUserCallSite()
       });
     }
+    const { aria } = computeFieldIdentity(formInstanceId, state.formKey, pathKey);
+    const isRequired = state.schema.isRequiredAtPath(segments);
+    const ariaEnabled = options?.autoAria ?? formAutoAria;
+    const ariaDisplayState = getDisplayStateAt !== void 0 ? computed(() => getDisplayStateAt(segments)) : void 0;
     const internalRv = {
       innerRef,
       displayValue,
@@ -2062,6 +2149,9 @@ function buildRegister(state, formInstanceId, instanceConfig) {
           })
         );
       },
+      markInteracted: () => {
+        state.markInteracted(segments);
+      },
       registerElement: (element) => {
         if (!INTERACTIVE_TAG_NAMES.has(element.tagName)) return;
         const added = state.registerElement(segments, element, formInstanceId);
@@ -2106,7 +2196,12 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       coerce,
       ...coerceElement !== void 0 ? { coerceElement } : {},
       acceptsUndefined,
-      acceptsString
+      acceptsString,
+      // --- Aria (internal; consumed by the directive) ---
+      aria,
+      isRequired,
+      ariaEnabled,
+      ...ariaDisplayState !== void 0 ? { ariaDisplayState } : {}
     };
     return shallowReadonly(internalRv);
   };
@@ -2350,15 +2445,34 @@ function buildFormApi(state, formInstanceId, options = {}) {
     if (instanceMeta === void 0) return meta;
     return meta === void 0 ? { instance: instanceMeta } : { ...meta, instance: instanceMeta };
   };
-  const registerConfig = {
-    ...instanceMeta !== void 0 ? { instanceMeta } : {},
-    ...options.coerce !== void 0 ? { coerce: options.coerce } : {}
+  const getFormMetaBase = () => {
+    const rootBase = buildContainerFieldStateBase(state, ROOT_PATH, ROOT_PATH_KEY, formInstanceId);
+    return {
+      ...rootBase,
+      submitting: state.submitting.value,
+      submissionAttempts: state.submissionAttempts.value,
+      departAttempts: state.departAttempts.value,
+      submitError: state.submitError.value,
+      errorCount: rootBase.errors.length,
+      submitted: state.submitted.value,
+      instanceId: formInstanceId
+    };
   };
-  const register = buildRegister(
+  const fieldStateAccessorOptions = options.getDisplayState !== void 0 ? { getDisplayState: options.getDisplayState } : void 0;
+  const getRootFieldStateAt = buildFieldStateAccessor(
     state,
     formInstanceId,
-    Object.keys(registerConfig).length > 0 ? registerConfig : void 0
+    getFormMetaBase,
+    fieldStateAccessorOptions
   );
+  const getDisplayStateAt = (segments) => getRootFieldStateAt(segments).value.displayState;
+  const registerConfig = {
+    ...instanceMeta !== void 0 ? { instanceMeta } : {},
+    ...options.coerce !== void 0 ? { coerce: options.coerce } : {},
+    ...options.autoAria !== void 0 ? { autoAria: options.autoAria } : {},
+    getDisplayStateAt
+  };
+  const register = buildRegister(state, formInstanceId, registerConfig);
   const processOptions = options.onInvalidSubmit !== void 0 ? { onInvalidSubmit: options.onInvalidSubmit } : {};
   const defaultInvalidSubmitPolicy = options.onInvalidSubmit ?? "focus-first-error";
   const {
@@ -2530,25 +2644,6 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const metaErrors = computed(
     () => aggregateErrorsAt(state, [])
   );
-  const getFormMetaBase = () => {
-    const rootBase = buildContainerFieldStateBase(state, ROOT_PATH);
-    return {
-      ...rootBase,
-      submitting: state.submitting.value,
-      submissionAttempts: state.submissionAttempts.value,
-      departAttempts: state.departAttempts.value,
-      submitError: state.submitError.value,
-      errorCount: rootBase.errors.length,
-      submitted: state.submitted.value,
-      instanceId: formInstanceId
-    };
-  };
-  const fieldStateAccessorOptions = options.shouldShowErrors !== void 0 ? { shouldShowErrors: options.shouldShowErrors } : void 0;
-  const getRootFieldStateAt = buildFieldStateAccessor(
-    state,
-    getFormMetaBase,
-    fieldStateAccessorOptions
-  );
   const rootFieldState = getRootFieldStateAt([]);
   const formMeta = readonly(
     reactive({
@@ -2563,6 +2658,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
       focused: computed(() => rootFieldState.value.focused),
       blurred: computed(() => rootFieldState.value.blurred),
       touched: computed(() => rootFieldState.value.touched),
+      interacted: computed(() => rootFieldState.value.interacted),
+      blurredAfterInteraction: computed(() => rootFieldState.value.blurredAfterInteraction),
       connected: computed(() => rootFieldState.value.connected),
       element: computed(() => rootFieldState.value.element),
       elements: computed(() => rootFieldState.value.elements),
@@ -2584,14 +2681,21 @@ function buildFormApi(state, formInstanceId, options = {}) {
       // keep the explicit form-level computation for the gate.
       valid,
       errors: metaErrors,
-      // `showErrors` / `firstError` flow through the same root
-      // field-state computed as the rest of the FieldState surface,
-      // so `form.meta.showErrors` matches `form.fields().showErrors`
-      // exactly — the predicate runs once at the root and the result
-      // is shared.
+      // `displayState` / the `show*` booleans / `firstError` flow
+      // through the same root field-state computed as the rest of the
+      // FieldState surface, so `form.meta.displayState` matches
+      // `form.fields().displayState` exactly — the predicate runs once
+      // at the root and the result is shared.
+      displayState: computed(() => rootFieldState.value.displayState),
       showErrors: computed(() => rootFieldState.value.showErrors),
+      showPending: computed(() => rootFieldState.value.showPending),
+      showSuccess: computed(() => rootFieldState.value.showSuccess),
+      showIdle: computed(() => rootFieldState.value.showIdle),
       firstError: computed(() => rootFieldState.value.firstError),
       path: computed(() => rootFieldState.value.path),
+      id: computed(() => rootFieldState.value.id),
+      aria: computed(() => rootFieldState.value.aria),
+      key: computed(() => rootFieldState.value.key),
       blank: computed(() => rootFieldState.value.blank),
       label: computed(() => rootFieldState.value.label),
       description: computed(() => rootFieldState.value.description),
@@ -2707,13 +2811,41 @@ function buildFormApi(state, formInstanceId, options = {}) {
     return Object.freeze(view);
   });
   const valuesProxy = buildValuesProxy(state.form);
-  const fieldStateProxy = buildFieldStateProxy(state, getFormMetaBase, fieldStateAccessorOptions);
+  const fieldStateProxy = buildFieldStateProxy(
+    state,
+    formInstanceId,
+    getFormMetaBase,
+    fieldStateAccessorOptions
+  );
   function gated(fn) {
     return ((...args) => {
       void state.activate();
       return fn(...args);
     });
   }
+  const callTerminal = fieldStateProxy;
+  const EMPTY_FIELD_LIST = Object.freeze([]);
+  function list(path) {
+    const { segments } = canonicalizePath(path);
+    const value = state.getValueAtPath(segments);
+    if (!Array.isArray(value)) return EMPTY_FIELD_LIST;
+    const out = new Array(value.length);
+    for (let i = 0; i < value.length; i += 1) out[i] = callTerminal(`${path}.${i}`);
+    return Object.freeze(out);
+  }
+  const EMPTY_FIELD_RECORD = Object.freeze({});
+  function record(path) {
+    const { segments } = canonicalizePath(path);
+    const value = state.getValueAtPath(segments);
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+      return EMPTY_FIELD_RECORD;
+    }
+    const out = {};
+    for (const key of Object.keys(value)) {
+      out[key] = callTerminal(`${path}.${key}`);
+    }
+    return Object.freeze(out);
+  }
   return {
     handleSubmit: gated(handleSubmit),
     // Callable readonly Proxies (`values`, `fields`, `errors`) and the
@@ -2795,6 +2927,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
     swap: gated(fieldArrays.swap),
     move: gated(fieldArrays.move),
     replace: gated(fieldArrays.replace),
+    list: gated(list),
+    record: gated(record),
     get blankPaths() {
       void state.activate();
       return blankPathsView;
@@ -2802,28 +2936,186 @@ function buildFormApi(state, formInstanceId, options = {}) {
   };
 }
 
-const defaultShouldShowErrors = (field, formMeta) => {
-  const hasOwnError = field.errors.some(
-    (e) => e.path.length === field.path.length && e.path.every((s, i) => s === field.path[i])
-  );
-  if (!hasOwnError) return false;
-  if (field.validating === true) return false;
-  if (formMeta.submissionAttempts > 0) return true;
-  return field.touched === true && field.focused !== true;
-};
-const SHOW_ALWAYS = () => true;
-const SHOW_NEVER = () => false;
-function resolveShouldShowErrors(config) {
-  if (config === void 0) return defaultShouldShowErrors;
-  if (config === true) return SHOW_ALWAYS;
-  if (config === false) return SHOW_NEVER;
-  return config;
+function createArrayIdentity(getArrayLength) {
+  const tokens = /* @__PURE__ */ new Map();
+  const baselines = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const allocate = () => `k${(counter++).toString(36)}`;
+  function ensure(arrayKey, expectedLen) {
+    let ids = tokens.get(arrayKey);
+    const firstTrack = ids === void 0;
+    if (ids === void 0) {
+      ids = [];
+      tokens.set(arrayKey, ids);
+    }
+    while (ids.length < expectedLen) ids.push(allocate());
+    if (ids.length > expectedLen) ids.length = expectedLen;
+    if (firstTrack) baselines.set(arrayKey, [...ids]);
+    return ids;
+  }
+  function orderPristineForKey(arrayKey) {
+    const baseline = baselines.get(arrayKey);
+    const current = tokens.get(arrayKey);
+    if (baseline === void 0 || current === void 0) return true;
+    if (baseline.length !== current.length) return false;
+    for (let i = 0; i < current.length; i++) {
+      if (current[i] !== baseline[i]) return false;
+    }
+    return true;
+  }
+  return {
+    tokenAt(arraySegs, index) {
+      const len = getArrayLength(arraySegs);
+      if (index < 0 || index >= len) return "";
+      const ids = ensure(canonicalizePath(arraySegs).key, len);
+      return ids[index] ?? "";
+    },
+    applyOp(arraySegs, op) {
+      const arrayKey = canonicalizePath(arraySegs).key;
+      const postLen = getArrayLength(arraySegs);
+      const preLen = op.kind === "insert" ? postLen - 1 : op.kind === "remove" ? postLen + 1 : postLen;
+      const ids = ensure(arrayKey, Math.max(0, preLen));
+      switch (op.kind) {
+        case "insert":
+          ids.splice(op.index, 0, allocate());
+          return;
+        case "remove":
+          ids.splice(op.index, 1);
+          return;
+        case "move": {
+          const [moved] = ids.splice(op.from, 1);
+          ids.splice(op.to, 0, moved ?? allocate());
+          return;
+        }
+        case "swap": {
+          const tmp = ids[op.a] ?? allocate();
+          ids[op.a] = ids[op.b] ?? allocate();
+          ids[op.b] = tmp;
+          return;
+        }
+        case "replace-at":
+          ids[op.index] = allocate();
+          return;
+      }
+    },
+    realign(arraySegs) {
+      ensure(canonicalizePath(arraySegs).key, getArrayLength(arraySegs));
+    },
+    hasStructuralChangeUnder(prefix) {
+      for (const arrayKey of tokens.keys()) {
+        if (orderPristineForKey(arrayKey)) continue;
+        const segs = segmentsForPathKey(arrayKey);
+        if (segs === null) continue;
+        if (isPathPrefix(prefix, segs)) return true;
+      }
+      return false;
+    },
+    rebaselineAll() {
+      for (const arrayKey of [...tokens.keys()]) {
+        const segs = segmentsForPathKey(arrayKey);
+        if (segs === null) continue;
+        const ids = ensure(arrayKey, getArrayLength(segs));
+        baselines.set(arrayKey, [...ids]);
+      }
+    }
+  };
+}
+
+function remapForOp(op, oldLen) {
+  const moved = /* @__PURE__ */ new Map();
+  const vacated = /* @__PURE__ */ new Set();
+  const fresh = /* @__PURE__ */ new Set();
+  switch (op.kind) {
+    case "insert":
+      for (let i = op.index; i < oldLen; i++) moved.set(i, i + 1);
+      fresh.add(op.index);
+      return { moved, vacated, fresh };
+    case "remove":
+      vacated.add(op.index);
+      for (let i = op.index + 1; i < oldLen; i++) moved.set(i, i - 1);
+      return { moved, vacated, fresh };
+    case "move":
+      if (op.from !== op.to) {
+        moved.set(op.from, op.to);
+        if (op.from < op.to) {
+          for (let i = op.from + 1; i <= op.to; i++) moved.set(i, i - 1);
+        } else {
+          for (let i = op.to; i < op.from; i++) moved.set(i, i + 1);
+        }
+      }
+      return { moved, vacated, fresh };
+    case "swap":
+      if (op.a !== op.b) {
+        moved.set(op.a, op.b);
+        moved.set(op.b, op.a);
+      }
+      return { moved, vacated, fresh };
+    case "replace-at":
+      vacated.add(op.index);
+      fresh.add(op.index);
+      return { moved, vacated, fresh };
+  }
+}
+function changedIndices(remap) {
+  const changed = new Set(remap.vacated);
+  for (const [from, to] of remap.moved) {
+    changed.add(from);
+    changed.add(to);
+  }
+  for (const index of remap.fresh) changed.add(index);
+  return changed;
+}
+function elementIndexUnder(arrayPath, key, idxPos) {
+  const segments = segmentsForPathKey(key);
+  if (segments === null) return null;
+  if (!isPathPrefix(arrayPath, segments)) return null;
+  if (segments.length <= idxPos) return null;
+  const index = segments[idxPos];
+  return typeof index === "number" ? index : null;
+}
+function migrateMapSubtree(map, arrayPath, remap, rewriteValue) {
+  const idxPos = arrayPath.length;
+  const snapshots = [];
+  for (const [key, value] of map) {
+    const index = elementIndexUnder(arrayPath, key, idxPos);
+    if (index === null) continue;
+    if (!remap.moved.has(index) && !remap.vacated.has(index)) continue;
+    snapshots.push({ segments: [...segmentsForPathKey(key)], index, value });
+  }
+  if (snapshots.length === 0) return;
+  for (const snap of snapshots) map.delete(canonicalizePath(snap.segments).key);
+  for (const snap of snapshots) {
+    const target = remap.moved.get(snap.index);
+    if (target === void 0) continue;
+    const relocated = snap.segments.slice();
+    relocated[idxPos] = target;
+    map.set(canonicalizePath(relocated).key, rewriteValue(snap.value, relocated));
+  }
+}
+function migrateSetSubtree(set, arrayPath, remap) {
+  const idxPos = arrayPath.length;
+  const snapshots = [];
+  for (const key of set) {
+    const index = elementIndexUnder(arrayPath, key, idxPos);
+    if (index === null) continue;
+    if (!remap.moved.has(index) && !remap.vacated.has(index)) continue;
+    snapshots.push({ segments: [...segmentsForPathKey(key)], index });
+  }
+  if (snapshots.length === 0) return;
+  for (const snap of snapshots) set.delete(canonicalizePath(snap.segments).key);
+  for (const snap of snapshots) {
+    const target = remap.moved.get(snap.index);
+    if (target === void 0) continue;
+    const relocated = snap.segments.slice();
+    relocated[idxPos] = target;
+    set.add(canonicalizePath(relocated).key);
+  }
 }
 
 function isHydratedFieldRecord(value) {
   if (typeof value !== "object" || value === null) return false;
   const r = value;
-  return Array.isArray(r.path) && (typeof r.updatedAt === "string" || r.updatedAt === null) && typeof r.connected === "boolean" && (typeof r.focused === "boolean" || r.focused === null) && (typeof r.blurred === "boolean" || r.blurred === null) && typeof r.touched === "boolean";
+  return Array.isArray(r.path) && (typeof r.updatedAt === "string" || r.updatedAt === null) && typeof r.connected === "boolean" && (typeof r.focused === "boolean" || r.focused === null) && (typeof r.blurred === "boolean" || r.blurred === null) && typeof r.touched === "boolean" && typeof r.interacted === "boolean" && typeof r.blurredAfterInteraction === "boolean";
 }
 function isHydratedValidationErrorArray(value) {
   if (!Array.isArray(value)) return false;
@@ -3010,9 +3302,7 @@ function createFormStore(options) {
     noSyncPathCounts.set(path, current - 1);
   }
   const coerceIndex = resolveCoercionIndex(options.coerce);
-  const resolvedShouldShowErrors = resolveShouldShowErrors(
-    options.shouldShowErrors
-  );
+  const resolvedGetDisplayState = resolveGetDisplayState(options.getDisplayState);
   const resolvedIsSensitivePath = options.isSensitivePath ?? isSensitivePath;
   const resolvedSegmentMatchesSensitive = options.segmentMatchesSensitive ?? segmentMatchesSensitive;
   const cleanupHooks = [];
@@ -3052,6 +3342,16 @@ function createFormStore(options) {
     warn: true
   });
   const form = ref(stubbedInitialData);
+  const arrayIdentity = createArrayIdentity((arraySegs) => {
+    const v = getAtPath(form.value, arraySegs);
+    return Array.isArray(v) ? v.length : 0;
+  });
+  function arrayElementKey(path) {
+    if (path.length === 0) return "";
+    const last = path[path.length - 1];
+    if (typeof last === "number") return arrayIdentity.tokenAt(path.slice(0, -1), last);
+    return "";
+  }
   const fields = reactive(/* @__PURE__ */ new Map());
   const elements = reactive(/* @__PURE__ */ new Map());
   const elementToFormInstance = /* @__PURE__ */ new WeakMap();
@@ -3088,12 +3388,16 @@ function createFormStore(options) {
   }
   function applyArrayOpToMemory(arrayPath, op) {
     switch (op.kind) {
-      case "shift-from":
+      case "insert":
+      case "remove":
         clearVariantMemoryAtArrayIndices(arrayPath, (i) => i >= op.index);
         return;
-      case "shift-range":
-        clearVariantMemoryAtArrayIndices(arrayPath, (i) => i >= op.fromIndex && i <= op.toIndex);
+      case "move": {
+        const lo = Math.min(op.from, op.to);
+        const hi = Math.max(op.from, op.to);
+        clearVariantMemoryAtArrayIndices(arrayPath, (i) => i >= lo && i <= hi);
         return;
+      }
       case "swap":
         clearVariantMemoryAtArrayIndices(arrayPath, (i) => i === op.a || i === op.b);
         return;
@@ -3102,6 +3406,68 @@ function createFormStore(options) {
         return;
     }
   }
+  function migrateArrayElementState(arrayPath, remap) {
+    if (remap.moved.size === 0 && remap.vacated.size === 0) return;
+    migrateMapSubtree(fields, arrayPath, remap, (record, segments) => ({
+      ...record,
+      path: segments
+    }));
+    migrateMapSubtree(
+      userErrors,
+      arrayPath,
+      remap,
+      (errors, segments) => errors.map((error) => ({ ...error, path: [...segments] }))
+    );
+    migrateMapSubtree(originals, arrayPath, remap, (record, segments) => ({
+      segments,
+      value: record.value
+    }));
+    migrateSetSubtree(blankPaths, arrayPath, remap);
+    migrateSetSubtree(originalBlankPaths, arrayPath, remap);
+  }
+  function seedFreshElement(arrayPath, freshIndex) {
+    const elementPath = [...arrayPath, freshIndex];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    diffAndApply(void 0, getAtPath(form.value, elementPath), elementPath, (patch) => {
+      if (patch.kind !== "added") return;
+      const { key } = canonicalizePath(patch.path);
+      if (!originals.has(key)) originals.set(key, { segments: patch.path, value: void 0 });
+      touchFieldRecord(key, patch.path, { updatedAt: now });
+    });
+  }
+  function dropSchemaErrorsAtChangedIndices(arrayPath, remap) {
+    const changed = changedIndices(remap);
+    if (changed.size === 0) return;
+    const idxPos = arrayPath.length;
+    for (const key of [...schemaErrors.keys()]) {
+      const segs = segmentsForPathKey(key);
+      if (segs === null) continue;
+      if (!isPathPrefix(arrayPath, segs)) continue;
+      if (segs.length <= idxPos) continue;
+      const idx = segs[idxPos];
+      if (typeof idx === "number" && changed.has(idx)) schemaErrors.delete(key);
+    }
+  }
+  function abortValidationAtVacatedIndices(arrayPath, remap) {
+    if (remap.vacated.size === 0) return;
+    const idxPos = arrayPath.length;
+    for (const [key, entry] of [...fieldValidationState]) {
+      const segs = segmentsForPathKey(key);
+      if (segs === null) continue;
+      if (!isPathPrefix(arrayPath, segs)) continue;
+      if (segs.length <= idxPos) continue;
+      const idx = segs[idxPos];
+      if (typeof idx !== "number" || !remap.vacated.has(idx)) continue;
+      if (entry.timer !== null) {
+        clearTimeout(entry.timer);
+      } else if (!entry.settled) {
+        activeValidations.value = Math.max(0, activeValidations.value - 1);
+        decFieldValidation(key);
+      }
+      entry.controller.abort();
+      fieldValidationState.delete(key);
+    }
+  }
   const pathOrdinals = /* @__PURE__ */ new Map();
   let nextOrdinal = 0;
   function ensurePathOrdinal(key) {
@@ -3139,6 +3505,7 @@ function createFormStore(options) {
   const departAttempts = ref(0);
   const submissionGeneration = ref(0);
   const activeValidations = ref(0);
+  let lastValidatedSnapshot = null;
   const hydrating = ref(false);
   const hydrateError = ref(null);
   const defaultValuesFactory = ref(void 0);
@@ -3209,7 +3576,9 @@ function createFormStore(options) {
         connected: false,
         focused: null,
         blurred: null,
-        touched: false
+        touched: false,
+        interacted: false,
+        blurredAfterInteraction: false
       });
     });
     if (strict && !schemaResponse.success) {
@@ -3238,7 +3607,12 @@ function createFormStore(options) {
       blurred: patch.blurred !== void 0 ? patch.blurred : current?.blurred ?? null,
       // touched is plain `boolean`; `??` is equivalent to the explicit
       // guard here because `false` is not nullish.
-      touched: patch.touched ?? current?.touched ?? false
+      touched: patch.touched ?? current?.touched ?? false,
+      // interacted is sticky-true; a merge patch only ever sets it, so
+      // `??` preserves the current bit. It flips back to false solely
+      // through the reset paths, which reconstruct the record outright.
+      interacted: patch.interacted ?? current?.interacted ?? false,
+      blurredAfterInteraction: patch.blurredAfterInteraction ?? current?.blurredAfterInteraction ?? false
     });
   }
   function applyFormReplacement(next, meta) {
@@ -3384,12 +3758,20 @@ function createFormStore(options) {
       }
       return true;
     }
+    const oldArrayLength = Array.isArray(currentValue) ? currentValue.length : 0;
     const nextForm = setAtPathWithSchemaFill(form.value, schema, path, completedValue);
     applyFormReplacement(nextForm, meta);
     if (meta?.arrayOp !== void 0) {
+      const remap = remapForOp(meta.arrayOp, oldArrayLength);
+      migrateArrayElementState(path, remap);
+      for (const freshIndex of remap.fresh) seedFreshElement(path, freshIndex);
+      dropSchemaErrorsAtChangedIndices(path, remap);
+      abortValidationAtVacatedIndices(path, remap);
       applyArrayOpToMemory(path, meta.arrayOp);
+      arrayIdentity.applyOp(path, meta.arrayOp);
     } else if (Array.isArray(value) && Array.isArray(currentValue)) {
       clearVariantMemoryUnderPath(path);
+      arrayIdentity.realign(path);
     }
     const effectiveModeAfterWrite = meta?.instance?.validateOn ?? fieldValidationMode;
     if (effectiveModeAfterWrite === "change") {
@@ -3499,6 +3881,9 @@ function createFormStore(options) {
     const run = () => {
       fresh.timer = null;
       if (controller.signal.aborted) return;
+      if (effectiveMode === "blur") {
+        lastValidatedSnapshot = { value: structuralSnapshot(form.value) };
+      }
       let activeIncremented = false;
       try {
         activeValidations.value += 1;
@@ -3741,25 +4126,47 @@ function createFormStore(options) {
   }
   function markFocused(path, focused, meta) {
     const { key } = canonicalizePath(path);
+    const current = fields.get(key);
     touchFieldRecord(key, path, {
       focused,
       blurred: !focused,
       // `touched` flips to true on blur and stays true thereafter; while
       // a field is currently focused we keep whatever value it held.
-      touched: focused ? fields.get(key)?.touched ?? false : true
+      touched: focused ? current?.touched ?? false : true,
+      // `blurredAfterInteraction` flips true on the first blur that lands
+      // after a value edit and stays true. A tab-through blur before any
+      // edit leaves it false (`interacted` is still false at that blur),
+      // which is what keeps a clean tab-through from arming the gate.
+      blurredAfterInteraction: !focused && current?.interacted === true ? true : current?.blurredAfterInteraction ?? false
     });
     const focusMode = meta?.instance?.validateOn ?? fieldValidationMode;
     if (!focused && focusMode === "blur") {
-      scheduleFieldValidation(path, true, {
-        ...meta?.instance?.validateOn !== void 0 ? { mode: meta.instance.validateOn } : {},
-        ...meta?.instance?.debounceMs !== void 0 ? { debounceMs: meta.instance.debounceMs } : {}
-      });
+      const firstInteractiveBlur = current?.interacted === true && current.blurredAfterInteraction !== true;
+      const snapshot = lastValidatedSnapshot;
+      let changed = true;
+      if (!firstInteractiveBlur && snapshot !== null) {
+        changed = false;
+        diffAndApply(snapshot.value, form.value, [], () => {
+          changed = true;
+        });
+      }
+      if (changed) {
+        scheduleFieldValidation(path, true, {
+          ...meta?.instance?.validateOn !== void 0 ? { mode: meta.instance.validateOn } : {},
+          ...meta?.instance?.debounceMs !== void 0 ? { debounceMs: meta.instance.debounceMs } : {}
+        });
+      }
     }
   }
   function markTouched(path) {
     const { key } = canonicalizePath(path);
     touchFieldRecord(key, path, { touched: true });
   }
+  function markInteracted(path) {
+    const { key } = canonicalizePath(path);
+    if (fields.get(key)?.interacted === true) return;
+    touchFieldRecord(key, path, { interacted: true });
+  }
   function touchAtPath(segments) {
     const formValue = form.value;
     let touchedAny = false;
@@ -3870,6 +4277,7 @@ function createFormStore(options) {
     const next = resetResponse.data;
     rebuildAuthoredPaths(resetSource, next);
     applyFormReplacement(next);
+    arrayIdentity.rebaselineAll();
     originals.clear();
     diffAndApply({}, next, [], (patch) => {
       if (patch.kind !== "added") return;
@@ -3913,7 +4321,9 @@ function createFormStore(options) {
         connected: record.connected,
         focused: record.focused,
         blurred: record.blurred,
-        touched: false
+        touched: false,
+        interacted: false,
+        blurredAfterInteraction: false
       });
     }
     submissionGeneration.value += 1;
@@ -3997,7 +4407,9 @@ function createFormStore(options) {
       connected: record.connected,
       focused: record.focused,
       blurred: record.blurred,
-      touched: false
+      touched: false,
+      interacted: false,
+      blurredAfterInteraction: false
     });
   }
   function isPathPrefix(prefix, candidate) {
@@ -4014,6 +4426,9 @@ function createFormStore(options) {
     if (entry === void 0) return true;
     return Object.is(getAtPath(form.value, segments), entry.value);
   }
+  function hasStructuralChangeUnder(path) {
+    return arrayIdentity.hasStructuralChangeUnder(path);
+  }
   function getFieldRecord(path) {
     const { key } = canonicalizePath(path);
     return fields.get(key);
@@ -4057,7 +4472,7 @@ function createFormStore(options) {
     originals,
     schema,
     ssr,
-    shouldShowErrors: resolvedShouldShowErrors,
+    getDisplayState: resolvedGetDisplayState,
     submitting,
     activeSubmissions,
     submissionAttempts,
@@ -4080,6 +4495,7 @@ function createFormStore(options) {
     applyFormReplacement,
     setValueAtPath,
     getValueAtPath,
+    arrayElementKey,
     reset,
     resetField,
     clear,
@@ -4096,9 +4512,11 @@ function createFormStore(options) {
     deregisterElement,
     markFocused,
     markTouched,
+    markInteracted,
     touchAtPath,
     markConnectedOptimistically,
     isPristineAtPath,
+    hasStructuralChangeUnder,
     getFieldRecord,
     getOriginalAtPath,
     getFirstErrorElement,
@@ -4315,19 +4733,6 @@ function createHistoryModule(state, config) {
   };
 }
 
-function hashStableString(input, seed = 0) {
-  let h1 = 3735928559 ^ seed;
-  let h2 = 1103547991 ^ seed;
-  for (let i = 0; i < input.length; i++) {
-    const ch = input.charCodeAt(i);
-    h1 = Math.imul(h1 ^ ch, 2654435761);
-    h2 = Math.imul(h2 ^ ch, 1597334677);
-  }
-  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
-  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
-  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36).padStart(11, "0");
-}
-
 const PROTOCOL_VERSION = 1;
 const JOIN_COLLECTION_WINDOW_MS = 50;
 const SNAPSHOT_TIMEOUT_MS = 200;
@@ -4850,8 +5255,8 @@ function useAbstractForm(configuration, options) {
   if (mergedDebounceMs !== void 0) {
     apiOptions.debounceMs = mergedDebounceMs;
   }
-  if (merged.shouldShowErrors !== void 0) {
-    apiOptions.shouldShowErrors = resolveShouldShowErrors(merged.shouldShowErrors);
+  if (merged.getDisplayState !== void 0) {
+    apiOptions.getDisplayState = merged.getDisplayState;
   }
   if (merged.coerce !== void 0) {
     apiOptions.coerce = merged.coerce;
@@ -4859,6 +5264,9 @@ function useAbstractForm(configuration, options) {
   if (merged.rememberVariants !== void 0) {
     apiOptions.rememberVariants = merged.rememberVariants;
   }
+  if (merged.autoAria !== void 0) {
+    apiOptions.autoAria = merged.autoAria;
+  }
   return buildFormApi(
     state,
     formInstanceId,
@@ -4873,10 +5281,11 @@ function mergeWithDefaults(defaults, configuration) {
   const coerce = configuration.coerce ?? defaults.coerce;
   const validateOn = configuration.validateOn ?? defaults.validateOn;
   const debounceMs = configuration.debounceMs ?? defaults.debounceMs;
-  const shouldShowErrors = configuration.shouldShowErrors ?? defaults.shouldShowErrors;
+  const getDisplayState = configuration.getDisplayState ?? defaults.getDisplayState;
   const maxRecursionDepth = configuration.maxRecursionDepth ?? defaults.maxRecursionDepth;
   const sensitiveNames = configuration.sensitiveNames ?? defaults.sensitiveNames;
   const multiTab = configuration.multiTab ?? defaults.multiTab;
+  const autoAria = configuration.autoAria ?? defaults.autoAria;
   return {
     ...configuration,
     ...strict === void 0 ? {} : { strict },
@@ -4886,10 +5295,11 @@ function mergeWithDefaults(defaults, configuration) {
     ...coerce === void 0 ? {} : { coerce },
     ...validateOn === void 0 ? {} : { validateOn },
     ...debounceMs === void 0 ? {} : { debounceMs },
-    ...shouldShowErrors === void 0 ? {} : { shouldShowErrors },
+    ...getDisplayState === void 0 ? {} : { getDisplayState },
     ...maxRecursionDepth === void 0 ? {} : { maxRecursionDepth },
     ...sensitiveNames === void 0 ? {} : { sensitiveNames },
-    ...multiTab === void 0 ? {} : { multiTab }
+    ...multiTab === void 0 ? {} : { multiTab },
+    ...autoAria === void 0 ? {} : { autoAria }
   };
 }
 const HISTORY_MODULE_KEY = "history";
@@ -4933,7 +5343,7 @@ function buildFreshState(key, schema, configuration, registry) {
     } : {},
     ...configuration.rememberVariants !== void 0 ? { rememberVariants: configuration.rememberVariants } : {},
     ...configuration.coerce !== void 0 ? { coerce: configuration.coerce } : {},
-    ...configuration.shouldShowErrors !== void 0 ? { shouldShowErrors: configuration.shouldShowErrors } : {},
+    ...configuration.getDisplayState !== void 0 ? { getDisplayState: configuration.getDisplayState } : {},
     ...initialBlankPaths !== void 0 ? { initialBlankPaths } : {},
     ...resolvedIsSensitivePath !== void 0 ? { isSensitivePath: resolvedIsSensitivePath } : {},
     ...resolvedSegmentMatchesSensitive !== void 0 ? { segmentMatchesSensitive: resolvedSegmentMatchesSensitive } : {}
@@ -6401,5 +6811,5 @@ function warnIfAmbientWizardProviderHadDuplicates() {
   }
 }
 
-export { AttaformErrorCode as A, defaultShouldShowErrors as a, defineCoercion as b, injectWizard as c, defaultCoercionRules as d, isPlainRecord as e, isUnset as f, getAtPath as g, humanize as h, injectForm as i, slimKindOf as j, useAbstractForm as k, lazy as l, useWizard as m, normalizeNumericOption as n, setAtPath as s, unset as u };
-//# sourceMappingURL=attaform.CZ-XtZt_.mjs.map
+export { AttaformErrorCode as A, defaultDisplayState as a, defineCoercion as b, injectWizard as c, defaultCoercionRules as d, isPlainRecord as e, isUnset as f, getAtPath as g, humanize as h, injectForm as i, slimKindOf as j, useAbstractForm as k, lazy as l, useWizard as m, normalizeNumericOption as n, setAtPath as s, unset as u };
+//# sourceMappingURL=attaform.BTi-PsHr.mjs.map