formstand 0.26.0 → 0.26.1

package/dist/index.cjs

@@ -212,10 +212,12 @@ var hasOwnSlot = (obj, path) => parsePath(path).reduce(
 ).ok;
 var writeIntoArray = (arr, index, rest, value, kindAt, prefix) => {
   const length = Math.max(arr.length, index + 1);
-  return Array.from(
-    { length },
-    (_, i) => i === index ? writeSegments(arr[i], rest, value, kindAt, [...prefix, index]) : arr[i]
-  );
+  const child = writeSegments(arr[index], rest, value, kindAt, [
+    ...prefix,
+    index
+  ]);
+  if (index < arr.length && child === arr[index]) return arr;
+  return Array.from({ length }, (_, i) => i === index ? child : arr[i]);
 };
 var refusesHugeIndex = (index) => {
   if (index > MAX_ARRAY_INDEX) {
@@ -247,10 +249,12 @@ var writeSegments = (obj, segments, value, kindAt, prefix) => {
       return obj;
     }
     const key2 = String(head);
-    return {
-      ...obj,
-      [key2]: writeSegments(obj[key2], rest, value, kindAt, [...prefix, key2])
-    };
+    const child = writeSegments(obj[key2], rest, value, kindAt, [
+      ...prefix,
+      key2
+    ]);
+    if (child === obj[key2] && Object.hasOwn(obj, key2)) return obj;
+    return { ...obj, [key2]: child };
   }
   const kind = kindAt?.(prefix.map(String).join(".")) ?? (typeof head === "number" ? "array" : "record");
   if (kind === "array") {
@@ -329,7 +333,11 @@ var unwrapForWalk = (s) => {
   if (s instanceof zod.z.ZodDefault || s instanceof zod.z.ZodPrefault || s instanceof zod.z.ZodCatch || s instanceof zod.z.ZodReadonly || s instanceof zod.z.ZodNonOptional) {
     return s.def.innerType;
   }
-  if (s instanceof zod.z.ZodPipe) return s.def.in;
+  if (s instanceof zod.z.ZodPipe) {
+    const input = s.def.in;
+    return input instanceof zod.z.ZodTransform ? s.def.out : input;
+  }
+  if (s instanceof zod.z.ZodLazy) return s.def.getter();
   return null;
 };
 var isLeafSchema = (s) => s instanceof zod.z.ZodString || s instanceof zod.z.ZodNumber || s instanceof zod.z.ZodBoolean || s instanceof zod.z.ZodBigInt || s instanceof zod.z.ZodDate || s instanceof zod.z.ZodEnum || s instanceof zod.z.ZodLiteral || s instanceof zod.z.ZodNull || s instanceof zod.z.ZodUndefined || s instanceof zod.z.ZodVoid || s instanceof zod.z.ZodNaN || s instanceof zod.z.ZodSymbol;
@@ -395,10 +403,31 @@ var hasChecks = (s) => {
   const checks = s.def.checks;
   return checks !== void 0 && checks.length > 0;
 };
-var fieldSchemaForIntrospection = (schema, path) => {
-  const childOf = (s, segment) => {
+var optionClaims = (option, discriminator, tag) => {
+  const strip = (s) => {
     const inner = unwrapForWalk(s);
-    if (inner !== null) return childOf(inner, segment);
+    return inner === null ? s : strip(inner);
+  };
+  const node = strip(option);
+  if (!(node instanceof zod.z.ZodObject)) return false;
+  const shape = node.shape;
+  const at = Object.hasOwn(shape, discriminator) ? shape[discriminator] : void 0;
+  if (at === void 0) return false;
+  const leaf = strip(at);
+  if (leaf instanceof zod.z.ZodLiteral) {
+    return leaf.def.values.includes(tag);
+  }
+  if (leaf instanceof zod.z.ZodEnum) {
+    return Object.values(leaf.def.entries).includes(
+      tag
+    );
+  }
+  return false;
+};
+var fieldSchemaForIntrospection = (schema, path, values) => {
+  const childOf = (s, segment, holder) => {
+    const inner = unwrapForWalk(s);
+    if (inner !== null) return childOf(inner, segment, holder);
     if (s instanceof zod.z.ZodObject && typeof segment === "string") {
       const shape = s.shape;
       return Object.hasOwn(shape, segment) ? shape[segment] ?? null : null;
@@ -412,19 +441,45 @@ var fieldSchemaForIntrospection = (schema, path) => {
     if (s instanceof zod.z.ZodRecord) {
       return s.valueType;
     }
+    if (s instanceof zod.z.ZodIntersection) {
+      return childOf(s.def.left, segment, holder) ?? childOf(s.def.right, segment, holder);
+    }
     if (s instanceof zod.z.ZodDiscriminatedUnion || s instanceof zod.z.ZodUnion) {
       const options = s.def.options;
-      return options.reduce(
-        (found, option) => found ?? childOf(option, segment),
+      const discriminator = s instanceof zod.z.ZodDiscriminatedUnion ? s.def.discriminator : null;
+      const tag = discriminator !== null && typeof holder === "object" && holder !== null ? holder[discriminator] : void 0;
+      const live = discriminator === null || tag === void 0 ? void 0 : options.find((option) => optionClaims(option, discriminator, tag));
+      const candidates = live === void 0 ? options : [live];
+      return candidates.reduce(
+        (found, option) => found ?? childOf(option, segment, holder),
         null
       );
     }
     return null;
   };
-  return parsePath(path).reduce(
-    (current, segment) => current === null ? null : childOf(current, segment),
-    schema
-  );
+  const segments = parsePath(path);
+  return segments.reduce(
+    (acc, segment) => acc.s === null ? acc : {
+      s: childOf(
+        acc.s,
+        segment,
+        values === void 0 ? void 0 : getAtPath(values, acc.prefix)
+      ),
+      prefix: acc.prefix === "" ? String(segment) : `${acc.prefix}.${String(segment)}`
+    },
+    { s: schema, prefix: "" }
+  ).s;
+};
+var schemaAcceptsUndefined = (schema) => schema instanceof zod.z.ZodOptional || schema instanceof zod.z.ZodDefault || schema instanceof zod.z.ZodPrefault || schema instanceof zod.z.ZodNullable && schemaAcceptsUndefined(schema.unwrap());
+var isObjectSchemaAt = (schema, path) => {
+  const sub = fieldSchemaForIntrospection(schema, path);
+  if (sub === null) return true;
+  const strip = (s) => {
+    const inner = unwrapForWalk(s);
+    return inner === null ? s : strip(inner);
+  };
+  const node = strip(sub);
+  return !(node instanceof zod.z.ZodUnion || node instanceof zod.z.ZodDiscriminatedUnion || node instanceof zod.z.ZodRecord || node instanceof zod.z.ZodMap || node instanceof zod.z.ZodSet || node instanceof zod.z.ZodArray || node instanceof zod.z.ZodTuple || isLeafSchema(node));
 };
 var containerKindAt = (schema) => (prefix) => {
   const unwrapAll = (s) => {
@@ -544,7 +599,8 @@ var scopeParse = (result, path, viaSubschema) => {
 var pruneUnreported = (prev, full) => {
   const entries = Object.entries(prev);
   const kept = entries.filter(([k]) => Object.hasOwn(full, k));
-  return kept.length === entries.length ? prev : Object.fromEntries(kept);
+  const unchanged = kept.length === entries.length && kept.every(([k, list]) => full[k] === list);
+  return unchanged ? prev : Object.fromEntries(kept.map(([k, list]) => [k, full[k] ?? list]));
 };
 var dropEmptyLists = (map) => {
   const entries = Object.entries(map);
@@ -916,7 +972,14 @@ var createForm = (schema, options) => {
           fresh.flatMap((path) => Object.entries(errorsFor(path)))
         ),
         fresh,
-        parsed.kind === "full" ? parsed.errors : null
+        // The prune map describes the values the batch STARTED with.
+        // A skip scope (an index into an empty array) still reads as
+        // fresh after an unrelated change, so a batch can commit under
+        // changed values; pruning with the stale map then dropped
+        // errors committed elsewhere in flight (an email error landing
+        // while a wizard step with such a path validated). The prune
+        // rides only while the whole values reference held.
+        parsed.kind === "full" && live.values === valuesAtStart ? parsed.errors : null
       ),
       isValidating: omitKeys(state.isValidating, ownedKeys)
     }));
@@ -1090,12 +1153,14 @@ var createForm = (schema, options) => {
       }
     }
   };
-  if (options.validateOnMount === true) {
+  const judgeBaseline = () => {
+    if (options.validateOnMount !== true) return;
     const result = validate();
     if (result.kind === "pending") {
       void result.promise.catch(reportBackgroundFailure);
     }
-  }
+  };
+  judgeBaseline();
   return Object.freeze({
     schema,
     store,
@@ -1110,8 +1175,12 @@ var createForm = (schema, options) => {
       return store.subscribe((state) => {
         const next = snapshotField(state, path);
         if (!shallowFieldEqual(ref.current, next)) {
+          const prev = ref.current;
           ref.current = next;
-          listener(next);
+          listener(
+            next,
+            prev
+          );
         }
       });
     },
@@ -1146,10 +1215,12 @@ var createForm = (schema, options) => {
       if (Object.is(getAtPath(currentValues, path), value) && (value !== void 0 || hasOwnSlot(currentValues, path))) {
         return;
       }
+      const next = setAtPath(currentValues, path, value, kindAt);
+      if (next === currentValues) return;
       clearArrayOpsUnder(store, path);
       store.setState((state) => ({
         ...state,
-        values: setAtPath(state.values, path, value, kindAt),
+        values: next,
         ...errorChannels(state, {
           serverErrors: releaseSpine(state.serverErrors, path)
         })
@@ -1256,6 +1327,7 @@ var createForm = (schema, options) => {
         isValidating: emptyBools,
         isValidatingForm: false
       }));
+      judgeBaseline();
     },
     reset: (nextInitial, resetOptions) => {
       sequences.clear();
@@ -1280,6 +1352,7 @@ var createForm = (schema, options) => {
           isValidatingForm: false
         };
       });
+      if (resetOptions?.keepErrors !== true) judgeBaseline();
     },
     resetField: (path) => {
       const initialSlot = slotAtPath(
@@ -1374,6 +1447,7 @@ var createForm = (schema, options) => {
     },
     snapshot: () => store.getState(),
     restore: (snap) => {
+      sequences.clear();
       clearArrayOpsUnder(store, "");
       store.setState(() => {
         const schemaErrors = dropEmptyLists(snap.schemaErrors ?? emptyErrors);
@@ -1497,6 +1571,7 @@ var persistForm = (form, options) => {
   const schema = form.schema;
   const fillRequiredGaps = (draft, initial, path) => {
     if (!isPlainObject(draft) || !isPlainObject(initial)) return draft;
+    if (!isObjectSchemaAt(schema, path)) return draft;
     return Object.keys(initial).reduce(
       (acc, key) => {
         const childPath = joinPath(path, key);
@@ -1506,21 +1581,34 @@ var persistForm = (form, options) => {
         }
         if (initial[key] === void 0) return acc;
         const sub = fieldSchemaForIntrospection(schema, childPath);
-        return sub !== null && isClearableSchema(sub) ? acc : { ...acc, [key]: initial[key] };
+        return sub !== null && schemaAcceptsUndefined(sub) ? acc : { ...acc, [key]: initial[key] };
       },
       draft
     );
   };
+  const applying = { current: false };
   const applyDraft = (values) => {
     const filled = fillRequiredGaps(
       values,
       form.getState().initialValues,
       ""
     );
-    if (apply === "edit" || apply === "restore") {
-      form.setValues(filled);
-    } else {
-      form.adoptValues(filled);
+    applying.current = true;
+    try {
+      if (apply === "edit" || apply === "restore") {
+        form.setValues(filled);
+      } else {
+        form.adoptValues(filled);
+      }
+    } finally {
+      applying.current = false;
+    }
+  };
+  const isCurrent = (values) => {
+    try {
+      return JSON.stringify(values) === JSON.stringify(form.getState().values);
+    } catch {
+      return false;
     }
   };
   const referenceShape = () => {
@@ -1531,7 +1619,7 @@ var persistForm = (form, options) => {
     }
   };
   const flexibleAt = (path) => schemaAllowsKindChangeAt(schema, path);
-  const inspect = () => {
+  const inspect = (skipWhenCurrent) => {
     const raw = (() => {
       try {
         return storage === null ? null : storage.getItem(options.key);
@@ -1577,14 +1665,15 @@ var persistForm = (form, options) => {
           reason: `its shape conflicts with the form's initial values at "${conflict}" (set the version option when the schema changes)`
         };
       }
+      if (skipWhenCurrent && isCurrent(values)) return { kind: "applied" };
       applyDraft(values);
       return { kind: "applied" };
     } catch {
       return { kind: "ignored", reason: "it is not valid JSON" };
     }
   };
-  const load = () => {
-    const outcome = inspect();
+  const loadWith = (skipWhenCurrent) => {
+    const outcome = inspect(skipWhenCurrent);
     if (outcome.kind === "ignored" && isDevBuild()) {
       console.warn(
         `[formstand] persistForm: ignored the draft under "${options.key}": ${outcome.reason}. The next edit overwrites it.`
@@ -1592,6 +1681,7 @@ var persistForm = (form, options) => {
     }
     return outcome.kind === "applied";
   };
+  const load = () => loadWith(false);
   const writeDraft = (values) => {
     try {
       storage?.setItem(
@@ -1605,10 +1695,11 @@ var persistForm = (form, options) => {
   };
   const writes = createDebouncer(debounceMs);
   if (apply !== "manual") {
-    load();
+    loadWith(true);
   }
   const cleared = { current: false };
   const unsubscribe = form.watchValues((values) => {
+    if (applying.current) return;
     if (cleared.current && values === form.getState().initialValues) return;
     cleared.current = false;
     writes.schedule(() => writeDraft(values));
@@ -1637,15 +1728,27 @@ var usePersistForm = (form, options) => {
     latestOptions.current = options;
   });
   const key = options.key;
-  const storage = options.storage;
+  const hasStorage = options.storage !== void 0;
+  const storageProxy = react.useMemo(
+    () => ({
+      getItem: (k) => latestOptions.current.storage?.getItem(k) ?? null,
+      setItem: (k, v) => latestOptions.current.storage?.setItem(k, v),
+      removeItem: (k) => latestOptions.current.storage?.removeItem(k)
+    }),
+    []
+  );
   react.useEffect(() => {
-    const handle = persistForm(form, latestOptions.current);
+    const options2 = latestOptions.current;
+    const handle = persistForm(form, {
+      ...options2,
+      ...options2.storage === void 0 ? {} : { storage: storageProxy }
+    });
     inner.current = handle;
     return () => {
       inner.current = null;
       handle.dispose();
     };
-  }, [form, key, storage]);
+  }, [form, key, hasStorage, storageProxy]);
   return react.useMemo(
     () => ({
       load: () => inner.current?.load() ?? false,
@@ -1717,6 +1820,12 @@ var numberInputProps = (field) => ({
 });
 var dateToInputText = (value) => {
   if (value === void 0 || value === null) return "";
+  if (typeof value === "string") {
+    const text = value;
+    const parsed = parseDateText(text);
+    if (parsed.kind === "date") return dateToInputText(parsed.value);
+    if (/^\d{4}-\d{2}-\d{2}$/.test(text.trim())) return "";
+  }
   const date = value instanceof Date ? value : new Date(value);
   if (Number.isNaN(date.getTime())) return "";
   const pad = (part) => String(part).padStart(2, "0");
@@ -1825,6 +1934,15 @@ function useFormSelectorShallow(form, selector) {
 }
 
 // src/react/useFormSteps.ts
+var settleOnLiveValues = async (form, fields, round = 0) => {
+  const before = fields.map((path) => form.getField(path));
+  const result = await form.validateFieldsAsync(fields);
+  const changed = fields.some(
+    (path, i) => !Object.is(form.getField(path), before[i])
+  );
+  if (!changed) return result;
+  return round < 3 ? settleOnLiveValues(form, fields, round + 1) : null;
+};
 var useFormSteps = (form, steps) => {
   const [step, setStep] = react.useState(0);
   const [visited, setVisited] = react.useState(
@@ -1838,7 +1956,8 @@ var useFormSteps = (form, steps) => {
     async (index) => {
       const definition = latest.current[index];
       if (definition === void 0) return true;
-      const result = await form.validateFieldsAsync(definition.fields);
+      const result = await settleOnLiveValues(form, definition.fields);
+      if (result === null) return false;
       if (result.kind === "invalid") {
         Object.keys(result.errors).forEach((key) => {
           form.setTouched(key, true);
@@ -1850,46 +1969,49 @@ var useFormSteps = (form, steps) => {
     [form]
   );
   const currentStep = react.useRef(step);
-  react.useEffect(() => {
-    currentStep.current = step;
-  });
+  const navigate = react.useCallback((target) => {
+    currentStep.current = target;
+    setStep(target);
+  }, []);
   const next = react.useCallback(async () => {
-    const ok = await validateStep(step);
+    const from = currentStep.current;
+    const ok = await validateStep(from);
     if (!ok) return false;
-    if (currentStep.current !== step) return false;
-    const target = Math.min(step + 1, latest.current.length - 1);
-    setStep(target);
+    if (currentStep.current !== from) return false;
+    const target = Math.max(0, Math.min(from + 1, latest.current.length - 1));
+    navigate(target);
     setVisited((prev) => /* @__PURE__ */ new Set([...prev, target]));
     return true;
-  }, [validateStep, step]);
+  }, [validateStep, navigate]);
   const back = react.useCallback(() => {
-    setStep((prev) => Math.max(prev - 1, 0));
-  }, []);
+    navigate(Math.max(currentStep.current - 1, 0));
+  }, [navigate]);
   const goTo = react.useCallback(
     async (target) => {
       const count = latest.current.length;
       if (!Number.isFinite(target)) return currentStep.current;
+      const from = currentStep.current;
       const clamped = Math.max(0, Math.min(Math.trunc(target), count - 1));
-      if (clamped <= step) {
-        setStep(clamped);
+      if (clamped <= from) {
+        navigate(clamped);
         return clamped;
       }
-      const walk = async (from) => {
-        if (from >= clamped) return clamped;
-        return await validateStep(from) ? walk(from + 1) : from;
+      const walk = async (at) => {
+        if (at >= clamped) return clamped;
+        return await validateStep(at) ? walk(at + 1) : at;
       };
-      const landed = await walk(step);
-      if (currentStep.current !== step) return currentStep.current;
-      setStep(landed);
+      const landed = await walk(from);
+      if (currentStep.current !== from) return currentStep.current;
+      navigate(landed);
       setVisited(
         (prev) => /* @__PURE__ */ new Set([
           ...prev,
-          ...Array.from({ length: landed - step + 1 }, (_, i) => step + i)
+          ...Array.from({ length: landed - from + 1 }, (_, i) => from + i)
         ])
       );
       return landed;
     },
-    [validateStep, step]
+    [validateStep, navigate]
   );
   const errorFlags = useFormSelectorShallow(
     form,
@@ -1982,6 +2104,7 @@ var createFormContext = () => {
   return { Provider, useFormContext };
 };
 function useField(form, pathArg, options) {
+  const formSchema = form.schema;
   const slice = react$1.useStore(
     form.store,
     shallow.useShallow((state) => {
@@ -1997,25 +2120,26 @@ function useField(form, pathArg, options) {
         error: entryAt(state.errors, p),
         touched: flagAt(state.touched, p),
         dirty: isFieldDirty(value, initialValue2),
-        isValidating: flagAt(state.isValidating, p)
+        isValidating: flagAt(state.isValidating, p),
+        // Resolved inside the selector so a discriminant change re-reads
+        // the ACTIVE variant's wrapper for a key the variants share; the
+        // schema node is a stable reference, so the shallow compare holds.
+        schema: formSchema === void 0 ? null : fieldSchemaForIntrospection(formSchema, p, state.values)
       };
     })
   );
   const path = slice.path;
-  const formSchema = form.schema;
+  const sub = slice.schema;
   const initialValue = slice.initialValue;
   const { emptyValue, clearable } = react.useMemo(() => {
-    if (formSchema !== void 0) {
-      const sub = fieldSchemaForIntrospection(formSchema, path);
-      if (sub !== null) {
-        return {
-          emptyValue: emptyValueForSchema(sub),
-          clearable: isClearableSchema(sub)
-        };
-      }
+    if (sub !== null) {
+      return {
+        emptyValue: emptyValueForSchema(sub),
+        clearable: isClearableSchema(sub)
+      };
     }
     return initialValue === null ? { emptyValue: null, clearable: true } : { emptyValue: void 0, clearable: false };
-  }, [formSchema, path, initialValue]);
+  }, [sub, initialValue]);
   const debounceMs = options?.debounceMs;
   const debouncerRef = react.useRef(null);
   react.useEffect(() => {
@@ -2125,10 +2249,11 @@ function useField(form, pathArg, options) {
 }
 
 // src/react/useVariantField.ts
-function useVariantField(form, unionPath, field) {
+function useVariantField(form, unionPath, field, options) {
   return useField(
     form,
-    `${unionPath}.${field}`
+    `${unionPath}.${field}`,
+    options
   );
 }
 var EMPTY_ITEMS = [];
@@ -2291,6 +2416,12 @@ function useFieldArray(form, pathArg) {
   const items = slice.items;
   const error = slice.error;
   const ids = deriveIds(form.store, path, items).ids;
+  const validateNow = react.useCallback(() => {
+    const result = form.validateField?.(path);
+    if (result?.kind === "pending") {
+      void result.promise.catch(reportBackgroundFailure);
+    }
+  }, [form, path]);
   const revalidate = react.useCallback(() => {
     const state = form.store.getState();
     if (shouldValidateOn(
@@ -2300,9 +2431,9 @@ function useFieldArray(form, pathArg) {
       state.submitCount > 0,
       flagAt(state.touched, path)
     )) {
-      form.validateField?.(path);
+      validateNow();
     }
-  }, [form, path]);
+  }, [form, path, validateNow]);
   const push = react.useCallback(
     (item) => {
       form.arrayPush(path, item);
@@ -2367,13 +2498,17 @@ function useFieldArray(form, pathArg) {
       state.submitCount > 0,
       true
     )) {
-      form.validateField?.(path);
+      validateNow();
     }
-  }, [form, path]);
+  }, [form, path, validateNow]);
   const validate = react.useCallback(
     () => form.validateField?.(path) ?? { kind: "valid" },
     [form, path]
   );
+  const validateAsync2 = react.useCallback(
+    () => form.validateFieldAsync?.(path) ?? Promise.resolve({ kind: "valid" }),
+    [form, path]
+  );
   const replace = react.useCallback(
     (next) => {
       form.setValue?.(path, next);
@@ -2383,7 +2518,15 @@ function useFieldArray(form, pathArg) {
   );
   const update = react.useCallback(
     (index, item) => {
-      form.setValue?.(`${path}.${index}`, item);
+      const current = getAtPath(form.store.getState().values, path);
+      const length = Array.isArray(current) ? current.length : 0;
+      if (!Number.isInteger(index) || index < 0 || index >= length) {
+        console.warn(
+          `[formstand] array op on "${path}" with an out-of-range or non-integer index (length ${String(length)}). Operation skipped.`
+        );
+        return;
+      }
+      form.setValue?.(`${path}.${String(index)}`, item);
       revalidate();
     },
     [form, path, revalidate]
@@ -2415,6 +2558,7 @@ function useFieldArray(form, pathArg) {
       setTouched,
       onBlur,
       validate,
+      validateAsync: validateAsync2,
       push,
       remove,
       insert,
@@ -2438,6 +2582,7 @@ function useFieldArray(form, pathArg) {
       setTouched,
       onBlur,
       validate,
+      validateAsync2,
       push,
       remove,
       insert,
@@ -2465,7 +2610,7 @@ var useFormError = (form) => react$1.useStore(
 function useFormValues(form) {
   return react$1.useStore(form.store, (state) => state.values);
 }
-function useFields(form, paths) {
+function useFields(form, paths, options) {
   const [arity] = react.useState(paths.length);
   if (paths.length !== arity) {
     throw new Error(
@@ -2475,7 +2620,11 @@ function useFields(form, paths) {
   const fields = paths.map(
     (path) => (
       // eslint-disable-next-line react-hooks/rules-of-hooks -- a fixed hook count by the stable-arity contract above; each element must be a REAL UseFieldReturn so it spreads into the prop builders
-      useField(form, path)
+      useField(
+        form,
+        path,
+        options
+      )
     )
   );
   return react.useMemo(() => {
@@ -2538,10 +2687,11 @@ var capitalize = (name) => name.length === 0 ? name : name.charAt(0).toUpperCase
 var createFormHooks = (form, name) => {
   const structural = form;
   const useBoundField = (path, options) => useField(structural, path, options);
-  const useBoundVariantField = (unionPath, field) => useVariantField(
+  const useBoundVariantField = (unionPath, field, options) => useVariantField(
     structural,
     unionPath,
-    field
+    field,
+    options
   );
   const useBoundFieldArray = (path) => useFieldArray(structural, path);
   const useBoundVariantFieldArray = (unionPath, field) => useVariantFieldArray(
@@ -2557,9 +2707,10 @@ var createFormHooks = (form, name) => {
   const useBoundIsValidating = (path) => useIsValidating(structural, path);
   const useBoundIsSubmitting = () => useIsSubmitting(structural);
   const useBoundValues = () => useFormValues(structural);
-  const useBoundFields = (paths) => useFields(
+  const useBoundFields = (paths, options) => useFields(
     structural,
-    paths
+    paths,
+    options
   );
   const useBoundSubmitCount = () => useSubmitCount(structural);
   const useBoundSteps = (steps) => useFormSteps(form, steps);
@@ -2609,7 +2760,7 @@ var FieldShell = ({
   wrapLabel,
   children
 }) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "zf-field", children: [
-  wrapLabel === true ? /* @__PURE__ */ jsxRuntime.jsxs("label", { htmlFor: id, className: "zf-label", children: [
+  wrapLabel === true && label !== void 0 ? /* @__PURE__ */ jsxRuntime.jsxs("label", { htmlFor: id, className: "zf-label", children: [
     children,
     " ",
     label