attaform 0.18.1 → 0.19.0

package/dist/shared/{attaform.II89Pcf4.cjs → attaform.C1msmO2v.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 const vue = require('vue');
-const paths = require('./attaform.BqK_L4gK.cjs');
+const paths = require('./attaform.BqEfHpVB.cjs');
 
 const NOT_FOUND = Symbol("NOT_FOUND");
 function descendStep(value, segment) {
@@ -436,6 +436,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 (paths.__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,
@@ -469,21 +537,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 } = paths.canonicalizePath(pathInput);
     const cached = cache.get(key);
     if (cached !== void 0) return cached;
     const c = vue.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;
@@ -513,6 +581,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,
@@ -521,6 +591,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,
@@ -528,11 +600,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(paths.canonicalizePath(segments).key)?.value;
@@ -542,6 +614,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;
@@ -560,6 +634,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;
@@ -568,6 +644,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;
@@ -583,6 +663,8 @@ function buildContainerFieldStateBase(state, segments, _key) {
     focused,
     blurred,
     touched,
+    interacted,
+    blurredAfterInteraction,
     connected,
     element: null,
     elements: EMPTY_ELEMENTS,
@@ -591,6 +673,8 @@ function buildContainerFieldStateBase(state, segments, _key) {
     validating,
     valid,
     path: segments,
+    ...computeFieldIdentity(formInstanceId, state.formKey, key),
+    key: state.arrayElementKey(segments),
     blank,
     label,
     description: resolved.description,
@@ -598,15 +682,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;
@@ -988,19 +1086,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);
@@ -1018,11 +1116,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);
@@ -1041,6 +1135,8 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "focused",
   "blurred",
   "touched",
+  "interacted",
+  "blurredAfterInteraction",
   "connected",
   "element",
   "elements",
@@ -1048,20 +1144,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;
@@ -1168,29 +1272,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 (paths.__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;
@@ -1996,6 +2077,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 };
@@ -2050,6 +2133,10 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         callSite: paths.captureUserCallSite()
       });
     }
+    const { aria } = computeFieldIdentity(formInstanceId, state.formKey, pathKey);
+    const isRequired = state.schema.isRequiredAtPath(segments);
+    const ariaEnabled = options?.autoAria ?? formAutoAria;
+    const ariaDisplayState = getDisplayStateAt !== void 0 ? vue.computed(() => getDisplayStateAt(segments)) : void 0;
     const internalRv = {
       innerRef,
       displayValue,
@@ -2064,6 +2151,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);
@@ -2108,7 +2198,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 vue.shallowReadonly(internalRv);
   };
@@ -2352,15 +2447,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, paths.ROOT_PATH, paths.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 {
@@ -2532,25 +2646,6 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const metaErrors = vue.computed(
     () => aggregateErrorsAt(state, [])
   );
-  const getFormMetaBase = () => {
-    const rootBase = buildContainerFieldStateBase(state, paths.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 = vue.readonly(
     vue.reactive({
@@ -2565,6 +2660,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
       focused: vue.computed(() => rootFieldState.value.focused),
       blurred: vue.computed(() => rootFieldState.value.blurred),
       touched: vue.computed(() => rootFieldState.value.touched),
+      interacted: vue.computed(() => rootFieldState.value.interacted),
+      blurredAfterInteraction: vue.computed(() => rootFieldState.value.blurredAfterInteraction),
       connected: vue.computed(() => rootFieldState.value.connected),
       element: vue.computed(() => rootFieldState.value.element),
       elements: vue.computed(() => rootFieldState.value.elements),
@@ -2586,14 +2683,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: vue.computed(() => rootFieldState.value.displayState),
       showErrors: vue.computed(() => rootFieldState.value.showErrors),
+      showPending: vue.computed(() => rootFieldState.value.showPending),
+      showSuccess: vue.computed(() => rootFieldState.value.showSuccess),
+      showIdle: vue.computed(() => rootFieldState.value.showIdle),
       firstError: vue.computed(() => rootFieldState.value.firstError),
       path: vue.computed(() => rootFieldState.value.path),
+      id: vue.computed(() => rootFieldState.value.id),
+      aria: vue.computed(() => rootFieldState.value.aria),
+      key: vue.computed(() => rootFieldState.value.key),
       blank: vue.computed(() => rootFieldState.value.blank),
       label: vue.computed(() => rootFieldState.value.label),
       description: vue.computed(() => rootFieldState.value.description),
@@ -2709,13 +2813,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 } = paths.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 } = paths.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
@@ -2797,6 +2929,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;
@@ -2804,28 +2938,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(paths.canonicalizePath(arraySegs).key, len);
+      return ids[index] ?? "";
+    },
+    applyOp(arraySegs, op) {
+      const arrayKey = paths.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(paths.canonicalizePath(arraySegs).key, getArrayLength(arraySegs));
+    },
+    hasStructuralChangeUnder(prefix) {
+      for (const arrayKey of tokens.keys()) {
+        if (orderPristineForKey(arrayKey)) continue;
+        const segs = paths.segmentsForPathKey(arrayKey);
+        if (segs === null) continue;
+        if (paths.isPathPrefix(prefix, segs)) return true;
+      }
+      return false;
+    },
+    rebaselineAll() {
+      for (const arrayKey of [...tokens.keys()]) {
+        const segs = paths.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 = paths.segmentsForPathKey(key);
+  if (segments === null) return null;
+  if (!paths.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: [...paths.segmentsForPathKey(key)], index, value });
+  }
+  if (snapshots.length === 0) return;
+  for (const snap of snapshots) map.delete(paths.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(paths.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: [...paths.segmentsForPathKey(key)], index });
+  }
+  if (snapshots.length === 0) return;
+  for (const snap of snapshots) set.delete(paths.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(paths.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;
@@ -3012,9 +3304,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 ?? paths.isSensitivePath;
   const resolvedSegmentMatchesSensitive = options.segmentMatchesSensitive ?? paths.segmentMatchesSensitive;
   const cleanupHooks = [];
@@ -3054,6 +3344,16 @@ function createFormStore(options) {
     warn: true
   });
   const form = vue.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 = vue.reactive(/* @__PURE__ */ new Map());
   const elements = vue.reactive(/* @__PURE__ */ new Map());
   const elementToFormInstance = /* @__PURE__ */ new WeakMap();
@@ -3090,12 +3390,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;
@@ -3104,6 +3408,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 } = paths.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 = paths.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 = paths.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) {
@@ -3141,6 +3507,7 @@ function createFormStore(options) {
   const departAttempts = vue.ref(0);
   const submissionGeneration = vue.ref(0);
   const activeValidations = vue.ref(0);
+  let lastValidatedSnapshot = null;
   const hydrating = vue.ref(false);
   const hydrateError = vue.ref(null);
   const defaultValuesFactory = vue.ref(void 0);
@@ -3211,7 +3578,9 @@ function createFormStore(options) {
         connected: false,
         focused: null,
         blurred: null,
-        touched: false
+        touched: false,
+        interacted: false,
+        blurredAfterInteraction: false
       });
     });
     if (strict && !schemaResponse.success) {
@@ -3240,7 +3609,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) {
@@ -3386,12 +3760,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") {
@@ -3501,6 +3883,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;
@@ -3743,25 +4128,47 @@ function createFormStore(options) {
   }
   function markFocused(path, focused, meta) {
     const { key } = paths.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 } = paths.canonicalizePath(path);
     touchFieldRecord(key, path, { touched: true });
   }
+  function markInteracted(path) {
+    const { key } = paths.canonicalizePath(path);
+    if (fields.get(key)?.interacted === true) return;
+    touchFieldRecord(key, path, { interacted: true });
+  }
   function touchAtPath(segments) {
     const formValue = form.value;
     let touchedAny = false;
@@ -3872,6 +4279,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;
@@ -3915,7 +4323,9 @@ function createFormStore(options) {
         connected: record.connected,
         focused: record.focused,
         blurred: record.blurred,
-        touched: false
+        touched: false,
+        interacted: false,
+        blurredAfterInteraction: false
       });
     }
     submissionGeneration.value += 1;
@@ -3999,7 +4409,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) {
@@ -4016,6 +4428,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 } = paths.canonicalizePath(path);
     return fields.get(key);
@@ -4059,7 +4474,7 @@ function createFormStore(options) {
     originals,
     schema,
     ssr,
-    shouldShowErrors: resolvedShouldShowErrors,
+    getDisplayState: resolvedGetDisplayState,
     submitting,
     activeSubmissions,
     submissionAttempts,
@@ -4082,6 +4497,7 @@ function createFormStore(options) {
     applyFormReplacement,
     setValueAtPath,
     getValueAtPath,
+    arrayElementKey,
     reset,
     resetField,
     clear,
@@ -4098,9 +4514,11 @@ function createFormStore(options) {
     deregisterElement,
     markFocused,
     markTouched,
+    markInteracted,
     touchAtPath,
     markConnectedOptimistically,
     isPristineAtPath,
+    hasStructuralChangeUnder,
     getFieldRecord,
     getOriginalAtPath,
     getFirstErrorElement,
@@ -4317,19 +4735,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;
@@ -4852,8 +5257,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;
@@ -4861,6 +5266,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,
@@ -4875,10 +5283,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 },
@@ -4888,10 +5297,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";
@@ -4935,7 +5345,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 } : {}
@@ -6405,7 +6815,7 @@ function warnIfAmbientWizardProviderHadDuplicates() {
 
 exports.AttaformErrorCode = AttaformErrorCode;
 exports.defaultCoercionRules = defaultCoercionRules;
-exports.defaultShouldShowErrors = defaultShouldShowErrors;
+exports.defaultDisplayState = defaultDisplayState;
 exports.defineCoercion = defineCoercion;
 exports.getAtPath = getAtPath;
 exports.humanize = humanize;
@@ -6420,4 +6830,4 @@ exports.slimKindOf = slimKindOf;
 exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
 exports.useWizard = useWizard;
-//# sourceMappingURL=attaform.II89Pcf4.cjs.map
+//# sourceMappingURL=attaform.C1msmO2v.cjs.map