@ereo/forms 0.1.23

package/dist/index.js

@@ -0,0 +1,2945 @@
+// src/store.ts
+import { signal as signal2, batch } from "@ereo/state";
+
+// src/utils.ts
+function parsePath(path) {
+  if (!path)
+    return [];
+  const segments = [];
+  let current = "";
+  for (let i = 0;i < path.length; i++) {
+    const char = path[i];
+    if (char === ".") {
+      if (current) {
+        segments.push(isIndex(current) ? parseInt(current, 10) : current);
+        current = "";
+      }
+    } else if (char === "[") {
+      if (current) {
+        segments.push(isIndex(current) ? parseInt(current, 10) : current);
+        current = "";
+      }
+      const closeBracket = path.indexOf("]", i);
+      if (closeBracket !== -1) {
+        const indexStr = path.slice(i + 1, closeBracket);
+        const index = parseInt(indexStr, 10);
+        if (!isNaN(index)) {
+          segments.push(index);
+        } else if (indexStr) {
+          segments.push(indexStr);
+        }
+        i = closeBracket;
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    segments.push(isIndex(current) ? parseInt(current, 10) : current);
+  }
+  return segments;
+}
+function isIndex(str) {
+  return /^\d+$/.test(str);
+}
+function getPath(obj, path) {
+  if (!path)
+    return obj;
+  const segments = parsePath(path);
+  let current = obj;
+  for (const segment of segments) {
+    if (current == null)
+      return;
+    current = current[segment];
+  }
+  return current;
+}
+function setPath(obj, path, value) {
+  const segments = parsePath(path);
+  if (segments.length === 0)
+    return value;
+  return setPathRecursive(obj, segments, 0, value);
+}
+function setPathRecursive(current, segments, index, value) {
+  const segment = segments[index];
+  if (current !== null && current !== undefined && typeof current !== "object") {
+    const nextSegment2 = segments[index + 1];
+    current = typeof nextSegment2 === "number" ? [] : {};
+  }
+  if (index === segments.length - 1) {
+    if (Array.isArray(current)) {
+      const copy = [...current];
+      copy[segment] = value;
+      return copy;
+    }
+    return { ...current ?? {}, [segment]: value };
+  }
+  const next = current?.[segment];
+  const nextSegment = segments[index + 1];
+  const nextIsArray = typeof nextSegment === "number";
+  const nextValue = next ?? (nextIsArray ? [] : {});
+  const updated = setPathRecursive(nextValue, segments, index + 1, value);
+  if (Array.isArray(current)) {
+    const copy = [...current];
+    copy[segment] = updated;
+    return copy;
+  }
+  return { ...current ?? {}, [segment]: updated };
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object")
+    return obj;
+  if (typeof structuredClone === "function") {
+    return structuredClone(obj);
+  }
+  if (obj instanceof Date)
+    return new Date(obj.getTime());
+  if (obj instanceof RegExp)
+    return new RegExp(obj.source, obj.flags);
+  if (obj instanceof Map) {
+    const map = new Map;
+    for (const [k, v] of obj)
+      map.set(deepClone(k), deepClone(v));
+    return map;
+  }
+  if (obj instanceof Set) {
+    const set = new Set;
+    for (const v of obj)
+      set.add(deepClone(v));
+    return set;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    result[key] = deepClone(obj[key]);
+  }
+  return result;
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return false;
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a !== "object")
+    return false;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof Date || b instanceof Date)
+    return false;
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  if (a instanceof RegExp || b instanceof RegExp)
+    return false;
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size)
+      return false;
+    for (const [k, v] of a) {
+      if (!b.has(k) || !deepEqual(v, b.get(k)))
+        return false;
+    }
+    return true;
+  }
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size)
+      return false;
+    for (const v of a) {
+      if (!b.has(v))
+        return false;
+    }
+    return true;
+  }
+  if (Array.isArray(a) !== Array.isArray(b))
+    return false;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b))
+      return false;
+    if (a.length !== b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      if (!deepEqual(a[i], b[i]))
+        return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return false;
+  for (const key of keysA) {
+    if (!deepEqual(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function flattenToPaths(obj, prefix = "") {
+  const result = new Map;
+  if (obj === null || typeof obj !== "object") {
+    if (prefix)
+      result.set(prefix, obj);
+    return result;
+  }
+  if (Array.isArray(obj)) {
+    for (let i = 0;i < obj.length; i++) {
+      const path = prefix ? `${prefix}.${i}` : `${i}`;
+      const nested = flattenToPaths(obj[i], path);
+      for (const [k, v] of nested) {
+        result.set(k, v);
+      }
+    }
+    if (prefix)
+      result.set(prefix, obj);
+    return result;
+  }
+  if (prefix)
+    result.set(prefix, obj);
+  for (const key of Object.keys(obj)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    const value = obj[key];
+    if (value !== null && typeof value === "object") {
+      const nested = flattenToPaths(value, path);
+      for (const [k, v] of nested) {
+        result.set(k, v);
+      }
+      result.set(path, value);
+    } else {
+      result.set(path, value);
+    }
+  }
+  return result;
+}
+
+// src/proxy.ts
+var PROXY_MARKER = Symbol("ereo-form-proxy");
+function createValuesProxy(store, basePath = "", proxyCache) {
+  const cache = proxyCache ?? new Map;
+  if (basePath && cache.has(basePath)) {
+    return cache.get(basePath);
+  }
+  const proxy = new Proxy({}, {
+    get(_target, prop, _receiver) {
+      if (prop === PROXY_MARKER)
+        return true;
+      if (typeof prop === "symbol")
+        return;
+      const fullPath = basePath ? `${basePath}.${String(prop)}` : String(prop);
+      const value = store.getValue(fullPath);
+      if (value !== null && typeof value === "object") {
+        return createValuesProxy(store, fullPath, cache);
+      }
+      return value;
+    },
+    set(_target, prop, value) {
+      if (typeof prop === "symbol")
+        return true;
+      const fullPath = basePath ? `${basePath}.${String(prop)}` : String(prop);
+      store.setValue(fullPath, value);
+      return true;
+    },
+    has(_target, prop) {
+      if (prop === PROXY_MARKER)
+        return true;
+      if (typeof prop === "symbol")
+        return false;
+      const obj = basePath ? store.getValue(basePath) : store.getValues();
+      if (obj !== null && typeof obj === "object") {
+        return String(prop) in obj;
+      }
+      return false;
+    },
+    ownKeys() {
+      const obj = basePath ? store.getValue(basePath) : store.getValues();
+      if (obj !== null && typeof obj === "object") {
+        return Object.keys(obj);
+      }
+      return [];
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      if (typeof prop === "symbol")
+        return;
+      const obj = basePath ? store.getValue(basePath) : store.getValues();
+      if (obj !== null && typeof obj === "object" && String(prop) in obj) {
+        const fullPath = basePath ? `${basePath}.${String(prop)}` : String(prop);
+        return {
+          configurable: true,
+          enumerable: true,
+          writable: true,
+          value: store.getValue(fullPath)
+        };
+      }
+      return;
+    }
+  });
+  if (basePath) {
+    cache.set(basePath, proxy);
+  }
+  return proxy;
+}
+
+// src/validation-engine.ts
+import { signal } from "@ereo/state";
+
+class ValidationEngine {
+  _store;
+  _fieldValidations = new Map;
+  _abortControllers = new Map;
+  _debounceTimers = new Map;
+  _validatingFields = new Set;
+  _validatingSignals = new Map;
+  _fieldGenerations = new Map;
+  _validateAllController = null;
+  constructor(store) {
+    this._store = store;
+    const { validators } = store.config;
+    if (validators) {
+      for (const [path, rules] of Object.entries(validators)) {
+        if (rules) {
+          const arr = Array.isArray(rules) ? rules : [rules];
+          this.registerFieldValidators(path, arr, store.config.validateOn);
+        }
+      }
+    }
+  }
+  registerFieldValidators(path, validators, explicitTrigger) {
+    const derivedTrigger = explicitTrigger ?? this._deriveValidateOn(validators);
+    this._fieldValidations.set(path, {
+      validators,
+      validateOn: explicitTrigger,
+      derivedTrigger
+    });
+  }
+  _deriveValidateOn(validators) {
+    const hasAsync = validators.some((v) => v._isAsync);
+    if (hasAsync)
+      return "change";
+    const allRequired = validators.every((v) => v._isRequired);
+    if (allRequired)
+      return "blur";
+    return "blur";
+  }
+  onFieldChange(path) {
+    const validation = this._fieldValidations.get(path);
+    if (!validation)
+      return;
+    const trigger = validation.validateOn ?? validation.derivedTrigger;
+    if (trigger !== "change")
+      return;
+    const debounceMs = this._getDebounceMs(validation.validators);
+    if (debounceMs > 0) {
+      this._debounceValidation(path, debounceMs);
+    } else {
+      this._runFieldValidation(path);
+    }
+  }
+  onFieldBlur(path) {
+    const validation = this._fieldValidations.get(path);
+    if (!validation)
+      return;
+    const trigger = validation.validateOn ?? validation.derivedTrigger;
+    if (trigger === "submit")
+      return;
+    const timer = this._debounceTimers.get(path);
+    if (timer) {
+      clearTimeout(timer);
+      this._debounceTimers.delete(path);
+    }
+    this._runFieldValidation(path);
+  }
+  isFieldValidating(path) {
+    return this._validatingFields.has(path);
+  }
+  getFieldValidatingSignal(path) {
+    let sig = this._validatingSignals.get(path);
+    if (!sig) {
+      sig = signal(false);
+      this._validatingSignals.set(path, sig);
+    }
+    return sig;
+  }
+  _setFieldValidating(path, validating) {
+    if (validating) {
+      this._validatingFields.add(path);
+    } else {
+      this._validatingFields.delete(path);
+    }
+    const sig = this._validatingSignals.get(path);
+    if (sig)
+      sig.set(validating);
+  }
+  async validateField(path) {
+    const validation = this._fieldValidations.get(path);
+    if (!validation)
+      return [];
+    this._cancelFieldValidation(path);
+    const controller = new AbortController;
+    this._abortControllers.set(path, controller);
+    const generation = (this._fieldGenerations.get(path) ?? 0) + 1;
+    this._fieldGenerations.set(path, generation);
+    this._setFieldValidating(path, true);
+    const errors = [];
+    const value = this._store.getValue(path);
+    const context = this._createContext(controller.signal);
+    try {
+      for (const validator of validation.validators) {
+        if (controller.signal.aborted)
+          break;
+        const result = await validator(value, context);
+        if (result) {
+          errors.push(result);
+        }
+      }
+    } finally {
+      if (this._abortControllers.get(path) === controller) {
+        this._setFieldValidating(path, false);
+        this._abortControllers.delete(path);
+      }
+    }
+    if (!controller.signal.aborted && this._fieldGenerations.get(path) === generation) {
+      this._store.setErrors(path, errors);
+      return errors;
+    }
+    return [];
+  }
+  async validateFields(paths) {
+    const allErrors = {};
+    let hasErrors = false;
+    await Promise.all(paths.map(async (path) => {
+      const errors = await this.validateField(path);
+      if (errors.length > 0) {
+        allErrors[path] = errors;
+        hasErrors = true;
+      }
+    }));
+    return { success: !hasErrors, errors: hasErrors ? allErrors : undefined };
+  }
+  async validateAll() {
+    if (this._validateAllController) {
+      this._validateAllController.abort();
+    }
+    const controller = new AbortController;
+    this._validateAllController = controller;
+    const allErrors = {};
+    let hasErrors = false;
+    const schema = this._store.config.schema;
+    if (schema) {
+      const schemaResult = await this._validateSchema(schema);
+      if (controller.signal.aborted)
+        return { success: true };
+      if (!schemaResult.success && schemaResult.errors) {
+        for (const [path, errors] of Object.entries(schemaResult.errors)) {
+          allErrors[path] = errors;
+          hasErrors = true;
+        }
+      }
+    }
+    const fieldPaths = Array.from(this._fieldValidations.keys());
+    await Promise.all(fieldPaths.map(async (path) => {
+      if (controller.signal.aborted)
+        return;
+      const validation = this._fieldValidations.get(path);
+      if (!validation)
+        return;
+      const value = this._store.getValue(path);
+      const context = this._createContext(controller.signal);
+      const errors = [];
+      for (const validator of validation.validators) {
+        if (controller.signal.aborted)
+          break;
+        const result = await validator(value, context);
+        if (result)
+          errors.push(result);
+      }
+      if (errors.length > 0 && !controller.signal.aborted) {
+        if (allErrors[path]) {
+          allErrors[path] = [...allErrors[path], ...errors];
+        } else {
+          allErrors[path] = errors;
+        }
+        hasErrors = true;
+      }
+    }));
+    if (controller.signal.aborted)
+      return { success: true };
+    if (this._validateAllController === controller) {
+      this._validateAllController = null;
+    }
+    this._store.clearErrors();
+    for (const [path, errors] of Object.entries(allErrors)) {
+      this._store.setErrors(path, errors);
+    }
+    return { success: !hasErrors, errors: hasErrors ? allErrors : undefined };
+  }
+  async _validateSchema(schema) {
+    const values = this._store._getCurrentValues();
+    if (schema.safeParse) {
+      const result = schema.safeParse(values);
+      if (result.success) {
+        return { success: true };
+      }
+      const errors = {};
+      if (result.error?.issues) {
+        for (const issue of result.error.issues) {
+          const path = issue.path.join(".");
+          if (!errors[path])
+            errors[path] = [];
+          errors[path].push(issue.message);
+        }
+      }
+      return { success: false, errors };
+    }
+    try {
+      schema.parse(values);
+      return { success: true };
+    } catch (e) {
+      if (e?.issues) {
+        const errors = {};
+        for (const issue of e.issues) {
+          const path = issue.path?.join(".") ?? "";
+          if (!errors[path])
+            errors[path] = [];
+          errors[path].push(issue.message);
+        }
+        return { success: false, errors };
+      }
+      return {
+        success: false,
+        errors: { "": [e?.message ?? "Validation failed"] }
+      };
+    }
+  }
+  unregisterField(path) {
+    this._cancelFieldValidation(path);
+    this._fieldValidations.delete(path);
+    this._validatingSignals.delete(path);
+    this._fieldGenerations.delete(path);
+  }
+  dispose() {
+    for (const timer of this._debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this._debounceTimers.clear();
+    for (const controller of this._abortControllers.values()) {
+      controller.abort();
+    }
+    this._abortControllers.clear();
+    this._validatingFields.clear();
+    this._validatingSignals.clear();
+    this._fieldGenerations.clear();
+    if (this._validateAllController) {
+      this._validateAllController.abort();
+      this._validateAllController = null;
+    }
+  }
+  _createContext(contextSignal) {
+    return {
+      getValue: (path) => this._store.getValue(path),
+      getValues: () => this._store._getCurrentValues(),
+      signal: contextSignal
+    };
+  }
+  _getDebounceMs(validators) {
+    for (const v of validators) {
+      if (v._debounce)
+        return v._debounce;
+      if (v._isAsync)
+        return 300;
+    }
+    return 0;
+  }
+  _debounceValidation(path, ms) {
+    const existing = this._debounceTimers.get(path);
+    if (existing)
+      clearTimeout(existing);
+    this._debounceTimers.set(path, setTimeout(() => {
+      this._debounceTimers.delete(path);
+      this._runFieldValidation(path);
+    }, ms));
+  }
+  _runFieldValidation(path) {
+    this.validateField(path).catch(() => {});
+  }
+  _cancelFieldValidation(path) {
+    const controller = this._abortControllers.get(path);
+    if (controller) {
+      controller.abort();
+      this._abortControllers.delete(path);
+    }
+    this._setFieldValidating(path, false);
+    const timer = this._debounceTimers.get(path);
+    if (timer) {
+      clearTimeout(timer);
+      this._debounceTimers.delete(path);
+    }
+  }
+}
+
+// src/store.ts
+class FormStore {
+  config;
+  _signals = new Map;
+  _errorSignals = new Map;
+  _formErrors;
+  _baseline;
+  _touchedSet = new Set;
+  _dirtySet = new Set;
+  _fieldRefs = new Map;
+  _fieldOptions = new Map;
+  _subscribers = new Set;
+  _watchers = new Map;
+  _submitAbort = null;
+  _submitGeneration = 0;
+  _validationEngine;
+  isValid;
+  isDirty;
+  isSubmitting;
+  submitState;
+  submitCount;
+  values;
+  constructor(config) {
+    this.config = config;
+    this._baseline = deepClone(config.defaultValues);
+    const paths = flattenToPaths(config.defaultValues);
+    for (const [path, value] of paths) {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        this._signals.set(path, signal2(value));
+      }
+    }
+    for (const [path, value] of paths) {
+      if (!this._signals.has(path)) {
+        this._signals.set(path, signal2(value));
+      }
+    }
+    this._formErrors = signal2([]);
+    this.isSubmitting = signal2(false);
+    this.submitState = signal2("idle");
+    this.submitCount = signal2(0);
+    this.isDirty = signal2(false);
+    this.isValid = signal2(true);
+    this.values = createValuesProxy(this);
+    this._validationEngine = new ValidationEngine(this);
+    if (config.validateOnMount) {
+      Promise.resolve().then(() => {
+        this._validationEngine.validateAll().catch(() => {});
+      });
+    }
+  }
+  getSignal(path) {
+    let sig = this._signals.get(path);
+    if (!sig) {
+      let value = getPath(this._baseline, path);
+      if (value === undefined) {
+        const parts = path.split(".");
+        for (let i = parts.length - 1;i >= 1; i--) {
+          const parentPath = parts.slice(0, i).join(".");
+          const parentSig = this._signals.get(parentPath);
+          if (parentSig) {
+            const parentVal = parentSig.get();
+            if (parentVal != null && typeof parentVal === "object") {
+              const rest = parts.slice(i);
+              let current = parentVal;
+              for (const part of rest) {
+                if (current == null || typeof current !== "object") {
+                  current = undefined;
+                  break;
+                }
+                current = current[part];
+              }
+              if (current !== undefined)
+                value = current;
+            }
+            break;
+          }
+        }
+      }
+      sig = signal2(value);
+      this._signals.set(path, sig);
+    }
+    return sig;
+  }
+  getErrors(path) {
+    let sig = this._errorSignals.get(path);
+    if (!sig) {
+      sig = signal2([]);
+      this._errorSignals.set(path, sig);
+    }
+    return sig;
+  }
+  getFormErrors() {
+    return this._formErrors;
+  }
+  getValue(path) {
+    return this.getSignal(path).get();
+  }
+  setValue(path, value) {
+    batch(() => {
+      const sig = this.getSignal(path);
+      const oldValue = sig.get();
+      if (oldValue === value)
+        return;
+      sig.set(value);
+      if (value !== null && typeof value === "object") {
+        this._syncChildSignals(path, value);
+      }
+      this._updateParentSignals(path, value);
+      const baselineValue = getPath(this._baseline, path);
+      if (deepEqual(value, baselineValue)) {
+        this._dirtySet.delete(path);
+      } else {
+        this._dirtySet.add(path);
+      }
+      this.isDirty.set(this._dirtySet.size > 0);
+      this._validationEngine.onFieldChange(path);
+      this._notifyWatchers(path, value);
+      this._notifySubscribers();
+    });
+  }
+  setValues(partial) {
+    batch(() => {
+      const paths = flattenToPaths(partial);
+      for (const [path, value] of paths) {
+        if (typeof value !== "object" || value === null) {
+          this.setValue(path, value);
+        }
+      }
+    });
+  }
+  getValues() {
+    return this._getCurrentValues();
+  }
+  _syncChildSignals(path, value) {
+    if (Array.isArray(value)) {
+      for (let i = 0;i < value.length; i++) {
+        const childPath = `${path}.${i}`;
+        const childSig = this._signals.get(childPath);
+        if (childSig) {
+          childSig.set(value[i]);
+        }
+        if (value[i] !== null && typeof value[i] === "object") {
+          this._syncChildSignals(childPath, value[i]);
+        }
+      }
+      const prefix = path + ".";
+      for (const key of [...this._signals.keys()]) {
+        if (key.startsWith(prefix)) {
+          const rest = key.slice(prefix.length);
+          const dotIdx = rest.indexOf(".");
+          const segment = dotIdx === -1 ? rest : rest.slice(0, dotIdx);
+          const idx = parseInt(segment, 10);
+          if (!isNaN(idx) && idx >= value.length) {
+            this._signals.delete(key);
+          }
+        }
+      }
+    } else if (typeof value === "object" && value !== null) {
+      for (const key of Object.keys(value)) {
+        const childPath = `${path}.${key}`;
+        const childSig = this._signals.get(childPath);
+        if (childSig) {
+          childSig.set(value[key]);
+        }
+        if (value[key] !== null && typeof value[key] === "object") {
+          this._syncChildSignals(childPath, value[key]);
+        }
+      }
+    }
+  }
+  _updateParentSignals(path, _childValue) {
+    const parts = path.split(".");
+    for (let i = parts.length - 1;i > 0; i--) {
+      const parentPath = parts.slice(0, i).join(".");
+      const parentSig = this._signals.get(parentPath);
+      if (parentSig) {
+        const newValue = this._reconstructValue(parentPath);
+        parentSig.set(newValue);
+        this._notifyWatchers(parentPath, newValue);
+      }
+    }
+  }
+  _reconstructValue(path) {
+    const baselineVal = getPath(this._baseline, path);
+    const currentSigVal = this._signals.get(path)?.get();
+    if (baselineVal === null || typeof baselineVal !== "object") {
+      return this.getSignal(path).get();
+    }
+    const prefix = path + ".";
+    const shapeSource = currentSigVal !== null && typeof currentSigVal === "object" ? currentSigVal : baselineVal;
+    if (Array.isArray(shapeSource) || Array.isArray(baselineVal)) {
+      const sourceArray = Array.isArray(shapeSource) ? shapeSource : baselineVal;
+      let maxLen = sourceArray.length;
+      for (const key of this._signals.keys()) {
+        if (key.startsWith(prefix)) {
+          const rest = key.slice(prefix.length);
+          const dotIdx = rest.indexOf(".");
+          const segment = dotIdx === -1 ? rest : rest.slice(0, dotIdx);
+          const idx = parseInt(segment, 10);
+          if (!isNaN(idx) && idx >= maxLen) {
+            maxLen = idx + 1;
+          }
+        }
+      }
+      const result2 = [];
+      for (let i = 0;i < maxLen; i++) {
+        const childPath = `${path}.${i}`;
+        const childSig = this._signals.get(childPath);
+        if (childSig) {
+          result2[i] = childSig.get();
+        } else {
+          const fromCurrent = Array.isArray(currentSigVal) ? currentSigVal[i] : undefined;
+          result2[i] = fromCurrent ?? baselineVal?.[i] ?? undefined;
+        }
+      }
+      return result2;
+    }
+    const result = {};
+    const keys = new Set(Object.keys(baselineVal));
+    for (const key of this._signals.keys()) {
+      if (key.startsWith(prefix)) {
+        const rest = key.slice(prefix.length);
+        const dotIdx = rest.indexOf(".");
+        const segment = dotIdx === -1 ? rest : rest.slice(0, dotIdx);
+        keys.add(segment);
+      }
+    }
+    for (const key of keys) {
+      const childPath = `${path}.${key}`;
+      const childSig = this._signals.get(childPath);
+      result[key] = childSig ? childSig.get() : baselineVal[key];
+    }
+    return result;
+  }
+  setErrors(path, errors) {
+    this.getErrors(path).set(errors);
+    this._updateIsValid();
+    this._notifySubscribers();
+  }
+  clearErrors(path) {
+    if (path) {
+      const sig = this._errorSignals.get(path);
+      if (sig)
+        sig.set([]);
+    } else {
+      for (const sig of this._errorSignals.values()) {
+        sig.set([]);
+      }
+      this._formErrors.set([]);
+    }
+    this._updateIsValid();
+    this._notifySubscribers();
+  }
+  setFormErrors(errors) {
+    this._formErrors.set(errors);
+    this._updateIsValid();
+    this._notifySubscribers();
+  }
+  _updateIsValid() {
+    let valid = this._formErrors.get().length === 0;
+    if (valid) {
+      for (const sig of this._errorSignals.values()) {
+        if (sig.get().length > 0) {
+          valid = false;
+          break;
+        }
+      }
+    }
+    this.isValid.set(valid);
+  }
+  getTouched(path) {
+    return this._touchedSet.has(path);
+  }
+  setTouched(path, touched = true) {
+    if (touched) {
+      this._touchedSet.add(path);
+    } else {
+      this._touchedSet.delete(path);
+    }
+    this._notifySubscribers();
+  }
+  triggerBlurValidation(path) {
+    this._validationEngine.onFieldBlur(path);
+  }
+  getDirty(path) {
+    return this._dirtySet.has(path);
+  }
+  register(path, options) {
+    if (options) {
+      this._fieldOptions.set(path, options);
+      if (options.validate) {
+        this._validationEngine.registerFieldValidators(path, Array.isArray(options.validate) ? options.validate : [options.validate], options.validateOn);
+      }
+    }
+    const value = this.getValue(path);
+    const errorsSig = this.getErrors(path);
+    const inputProps = {
+      name: path,
+      value,
+      onChange: (e) => {
+        let newValue;
+        if (options?.parse) {
+          newValue = options.parse(e);
+        } else if (e && typeof e === "object" && "target" in e) {
+          const target = e.target;
+          newValue = target.type === "checkbox" ? target.checked : target.value;
+        } else {
+          newValue = e;
+        }
+        if (options?.transform) {
+          newValue = options.transform(newValue);
+        }
+        this.setValue(path, newValue);
+      },
+      onBlur: () => {
+        this.setTouched(path);
+        this._validationEngine.onFieldBlur(path);
+      },
+      ref: (el) => {
+        this._fieldRefs.set(path, el);
+      }
+    };
+    const errors = errorsSig.get();
+    if (errors.length > 0) {
+      inputProps["aria-invalid"] = true;
+      inputProps["aria-describedby"] = `${path}-error`;
+    }
+    return {
+      inputProps,
+      state: {
+        value,
+        errors: errorsSig.get(),
+        touched: this.getTouched(path),
+        dirty: this.getDirty(path),
+        validating: this.getFieldValidating(path).get()
+      },
+      setValue: (v) => this.setValue(path, v),
+      setError: (errs) => this.setErrors(path, errs),
+      clearErrors: () => this.clearErrors(path),
+      setTouched: (t) => this.setTouched(path, t),
+      reset: () => {
+        const baseline = getPath(this._baseline, path);
+        this.setValue(path, baseline);
+        this.clearErrors(path);
+        this.setTouched(path, false);
+      }
+    };
+  }
+  unregister(path) {
+    this._fieldOptions.delete(path);
+    this._fieldRefs.delete(path);
+    this._validationEngine.unregisterField(path);
+  }
+  async handleSubmit(e) {
+    if (e)
+      e.preventDefault?.();
+    if (!this.config.onSubmit) {
+      await this._validationEngine.validateAll();
+      return;
+    }
+    await this.submitWith(this.config.onSubmit);
+  }
+  async submitWith(handler, _submitId) {
+    if (this.isSubmitting.get()) {
+      this._submitAbort?.abort();
+    }
+    const generation = ++this._submitGeneration;
+    const abortController = new AbortController;
+    this._submitAbort = abortController;
+    batch(() => {
+      this.isSubmitting.set(true);
+      this.submitState.set("submitting");
+      for (const path of this._fieldOptions.keys()) {
+        this._touchedSet.add(path);
+      }
+      this._notifySubscribers();
+    });
+    try {
+      const validationResult = await this._validationEngine.validateAll();
+      if (generation !== this._submitGeneration)
+        return;
+      if (!validationResult.success) {
+        batch(() => {
+          if (validationResult.errors) {
+            for (const [path, errors] of Object.entries(validationResult.errors)) {
+              this.setErrors(path, errors);
+            }
+          }
+          this.isSubmitting.set(false);
+          this.submitState.set("error");
+        });
+        return;
+      }
+      const values = this._getCurrentValues();
+      const formData = this._buildFormData(values);
+      await handler(values, {
+        values,
+        formData,
+        signal: abortController.signal
+      });
+      if (generation !== this._submitGeneration)
+        return;
+      batch(() => {
+        this.isSubmitting.set(false);
+        this.submitState.set("success");
+        this.submitCount.update((c) => c + 1);
+      });
+      if (this.config.resetOnSubmit) {
+        this.reset();
+      }
+    } catch (error) {
+      if (generation === this._submitGeneration && !abortController.signal.aborted) {
+        batch(() => {
+          this.isSubmitting.set(false);
+          this.submitState.set("error");
+        });
+      }
+      throw error;
+    }
+  }
+  async validate() {
+    const result = await this._validationEngine.validateAll();
+    return result.success;
+  }
+  reset() {
+    this.resetTo(deepClone(this.config.defaultValues));
+  }
+  resetTo(values) {
+    batch(() => {
+      this._baseline = deepClone(values);
+      const newPaths = flattenToPaths(values);
+      const newPathSet = new Set(newPaths.keys());
+      for (const path of this._signals.keys()) {
+        if (!newPathSet.has(path)) {
+          this._signals.delete(path);
+        }
+      }
+      for (const path of this._errorSignals.keys()) {
+        if (!newPathSet.has(path)) {
+          this._errorSignals.delete(path);
+        }
+      }
+      for (const [path, value] of newPaths) {
+        const sig = this._signals.get(path);
+        if (sig) {
+          sig.set(value);
+        } else {
+          this._signals.set(path, signal2(value));
+        }
+      }
+      this._touchedSet.clear();
+      this._dirtySet.clear();
+      this.isDirty.set(false);
+      this.clearErrors();
+      this.submitState.set("idle");
+      this._notifySubscribers();
+    });
+  }
+  setBaseline(values) {
+    batch(() => {
+      this._baseline = deepClone(values);
+      for (const path of this._signals.keys()) {
+        const current = this.getValue(path);
+        const base = getPath(this._baseline, path);
+        if (deepEqual(current, base)) {
+          this._dirtySet.delete(path);
+        } else {
+          this._dirtySet.add(path);
+        }
+      }
+      this.isDirty.set(this._dirtySet.size > 0);
+      this._notifySubscribers();
+    });
+  }
+  getChanges() {
+    let changes = {};
+    for (const path of this._dirtySet) {
+      const value = this.getValue(path);
+      changes = setPath(changes, path, value);
+    }
+    return changes;
+  }
+  watch(path, callback) {
+    if (!this._watchers.has(path)) {
+      this._watchers.set(path, new Set);
+    }
+    this._watchers.get(path).add(callback);
+    return () => {
+      const set = this._watchers.get(path);
+      if (set) {
+        set.delete(callback);
+        if (set.size === 0)
+          this._watchers.delete(path);
+      }
+    };
+  }
+  watchFields(paths, callback) {
+    const unsubs = paths.map((p) => this.watch(p, callback));
+    return () => unsubs.forEach((fn) => fn());
+  }
+  subscribe(callback) {
+    this._subscribers.add(callback);
+    return () => {
+      this._subscribers.delete(callback);
+    };
+  }
+  toJSON() {
+    return this._getCurrentValues();
+  }
+  toFormData() {
+    return this._buildFormData(this._getCurrentValues());
+  }
+  getFieldRef(path) {
+    return this._fieldRefs.get(path) ?? null;
+  }
+  setFieldRef(path, el) {
+    this._fieldRefs.set(path, el);
+  }
+  getFieldOptions(path) {
+    return this._fieldOptions.get(path);
+  }
+  getBaseline() {
+    return deepClone(this._baseline);
+  }
+  getFieldValidating(path) {
+    return this._validationEngine.getFieldValidatingSignal(path);
+  }
+  dispose() {
+    this._validationEngine.dispose();
+    this._subscribers.clear();
+    this._watchers.clear();
+    this._fieldRefs.clear();
+    this._fieldOptions.clear();
+    if (this._submitAbort) {
+      this._submitAbort.abort();
+      this._submitAbort = null;
+    }
+  }
+  _getCurrentValues() {
+    const result = deepClone(this._baseline);
+    for (const [path, sig] of this._signals) {
+      const value = sig.get();
+      const parts = path.split(".");
+      const baseValue = getPath(this._baseline, path);
+      if (baseValue === null || typeof baseValue !== "object" || Array.isArray(baseValue)) {
+        let current = result;
+        for (let i = 0;i < parts.length - 1; i++) {
+          const part = parts[i];
+          const idx = parseInt(part, 10);
+          if (!isNaN(idx)) {
+            if (!current[idx])
+              current[idx] = {};
+            current = current[idx];
+          } else {
+            if (!current[part])
+              current[part] = {};
+            current = current[part];
+          }
+        }
+        if (current != null) {
+          const lastPart = parts[parts.length - 1];
+          const lastIdx = parseInt(lastPart, 10);
+          if (!isNaN(lastIdx)) {
+            current[lastIdx] = value;
+          } else {
+            current[lastPart] = value;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  _buildFormData(values) {
+    if (typeof FormData === "undefined") {
+      throw new Error("FormData is not available in this environment. toFormData() cannot be used during SSR.");
+    }
+    const fd = new FormData;
+    const flat = flattenToPaths(values);
+    for (const [path, value] of flat) {
+      if (value instanceof File) {
+        fd.append(path, value);
+      } else if (typeof value !== "object" || value === null) {
+        fd.append(path, String(value ?? ""));
+      }
+    }
+    return fd;
+  }
+  _notifyWatchers(path, value) {
+    const set = this._watchers.get(path);
+    if (set) {
+      for (const cb of [...set]) {
+        cb(value, path);
+      }
+    }
+  }
+  _notifySubscribers() {
+    for (const cb of [...this._subscribers]) {
+      cb();
+    }
+  }
+}
+function createFormStore(config) {
+  return new FormStore(config);
+}
+// src/hooks.ts
+import { useRef, useCallback, useMemo, useEffect, useSyncExternalStore } from "react";
+import { useSignal } from "@ereo/state";
+function useForm(config) {
+  const storeRef = useRef(null);
+  if (!storeRef.current) {
+    storeRef.current = new FormStore(config);
+  }
+  useEffect(() => {
+    return () => {
+      storeRef.current?.dispose();
+    };
+  }, []);
+  return storeRef.current;
+}
+function useField(form, name, opts) {
+  const optsRef = useRef(opts);
+  const registered = useRef(false);
+  if (!registered.current || optsRef.current !== opts) {
+    optsRef.current = opts;
+    if (opts) {
+      form.register(name, opts);
+    }
+    registered.current = true;
+  }
+  useEffect(() => {
+    return () => {
+      form.unregister(name);
+    };
+  }, [form, name]);
+  const valueSig = form.getSignal(name);
+  const value = useSignal(valueSig);
+  const errorsSig = form.getErrors(name);
+  const errors = useSignal(errorsSig);
+  const touched = useSyncExternalStore(useCallback((cb) => form.subscribe(cb), [form]), () => form.getTouched(name), () => form.getTouched(name));
+  const dirty = useSyncExternalStore(useCallback((cb) => form.subscribe(cb), [form]), () => form.getDirty(name), () => form.getDirty(name));
+  const validatingSig = form.getFieldValidating(name);
+  const validating = useSignal(validatingSig);
+  const setValue = useCallback((v) => form.setValue(name, v), [form, name]);
+  const setError = useCallback((errs) => form.setErrors(name, errs), [form, name]);
+  const clearErrors = useCallback(() => form.clearErrors(name), [form, name]);
+  const setTouched = useCallback((t) => form.setTouched(name, t), [form, name]);
+  const reset = useCallback(() => {
+    const baseline = getPath(form.getBaseline(), name);
+    form.setValue(name, baseline);
+    form.clearErrors(name);
+    form.setTouched(name, false);
+  }, [form, name]);
+  const onChange = useCallback((e) => {
+    let newValue;
+    if (opts?.parse) {
+      newValue = opts.parse(e);
+    } else if (e && typeof e === "object" && "target" in e) {
+      const target = e.target;
+      newValue = target.type === "checkbox" ? target.checked : target.value;
+    } else {
+      newValue = e;
+    }
+    if (opts?.transform) {
+      newValue = opts.transform(newValue);
+    }
+    form.setValue(name, newValue);
+  }, [form, name, opts]);
+  const onBlur = useCallback(() => {
+    form.setTouched(name);
+    form.triggerBlurValidation(name);
+  }, [form, name]);
+  const refCallback = useCallback((el) => {
+    if (form.setFieldRef) {
+      form.setFieldRef(name, el);
+    }
+  }, [form, name]);
+  const inputProps = useMemo(() => ({
+    name,
+    value,
+    onChange,
+    onBlur,
+    ref: refCallback,
+    ...errors.length > 0 ? {
+      "aria-invalid": true,
+      "aria-describedby": `${name}-error`
+    } : {}
+  }), [name, value, onChange, onBlur, refCallback, errors]);
+  return {
+    inputProps,
+    value,
+    errors,
+    touched,
+    dirty,
+    validating,
+    setValue,
+    setError,
+    clearErrors,
+    setTouched,
+    reset
+  };
+}
+function useFieldArray(form, name) {
+  const idCounter = useRef(0);
+  const idsRef = useRef([]);
+  const arraySig = form.getSignal(name);
+  const rawArray = useSignal(arraySig);
+  const items = rawArray ?? [];
+  if (idsRef.current.length < items.length) {
+    for (let i = idsRef.current.length;i < items.length; i++) {
+      idsRef.current.push(`${name}-${idCounter.current++}`);
+    }
+  } else if (idsRef.current.length > items.length) {
+    idsRef.current.length = items.length;
+  }
+  const fields = useMemo(() => items.map((value, index) => ({
+    id: idsRef.current[index] ?? `${name}-fallback-${index}`,
+    value,
+    index
+  })), [items, name]);
+  const append = useCallback((value) => {
+    const current = form.getValue(name) ?? [];
+    idsRef.current = [...idsRef.current, `${name}-${idCounter.current++}`];
+    form.setValue(name, [...current, value]);
+  }, [form, name]);
+  const prepend = useCallback((value) => {
+    const current = form.getValue(name) ?? [];
+    idsRef.current = [`${name}-${idCounter.current++}`, ...idsRef.current];
+    form.setValue(name, [value, ...current]);
+  }, [form, name]);
+  const insert = useCallback((index, value) => {
+    const current = form.getValue(name) ?? [];
+    const next = [...current];
+    next.splice(index, 0, value);
+    const ids = [...idsRef.current];
+    ids.splice(index, 0, `${name}-${idCounter.current++}`);
+    idsRef.current = ids;
+    form.setValue(name, next);
+  }, [form, name]);
+  const remove = useCallback((index) => {
+    const current = form.getValue(name) ?? [];
+    const next = [...current];
+    next.splice(index, 1);
+    const ids = [...idsRef.current];
+    ids.splice(index, 1);
+    idsRef.current = ids;
+    form.setValue(name, next);
+  }, [form, name]);
+  const swap = useCallback((indexA, indexB) => {
+    const current = form.getValue(name) ?? [];
+    const next = [...current];
+    [next[indexA], next[indexB]] = [next[indexB], next[indexA]];
+    const ids = [...idsRef.current];
+    [ids[indexA], ids[indexB]] = [ids[indexB], ids[indexA]];
+    idsRef.current = ids;
+    form.setValue(name, next);
+  }, [form, name]);
+  const move = useCallback((from, to) => {
+    const current = form.getValue(name) ?? [];
+    const next = [...current];
+    const [item] = next.splice(from, 1);
+    next.splice(to, 0, item);
+    const ids = [...idsRef.current];
+    const [id] = ids.splice(from, 1);
+    ids.splice(to, 0, id);
+    idsRef.current = ids;
+    form.setValue(name, next);
+  }, [form, name]);
+  const replace = useCallback((index, value) => {
+    const current = form.getValue(name) ?? [];
+    const next = [...current];
+    next[index] = value;
+    form.setValue(name, next);
+  }, [form, name]);
+  const replaceAll = useCallback((values) => {
+    idsRef.current = values.map(() => `${name}-${idCounter.current++}`);
+    form.setValue(name, values);
+  }, [form, name]);
+  const clone = useCallback((index) => {
+    const current = form.getValue(name) ?? [];
+    const next = [...current];
+    const cloned = deepClone(current[index]);
+    next.splice(index + 1, 0, cloned);
+    const ids = [...idsRef.current];
+    ids.splice(index + 1, 0, `${name}-${idCounter.current++}`);
+    idsRef.current = ids;
+    form.setValue(name, next);
+  }, [form, name]);
+  return {
+    fields,
+    append,
+    prepend,
+    insert,
+    remove,
+    swap,
+    move,
+    replace,
+    replaceAll,
+    clone
+  };
+}
+function useFormStatus(form) {
+  const isSubmitting = useSignal(form.isSubmitting);
+  const submitState = useSignal(form.submitState);
+  const isValid = useSignal(form.isValid);
+  const isDirty = useSignal(form.isDirty);
+  const submitCount = useSignal(form.submitCount);
+  return { isSubmitting, submitState, isValid, isDirty, submitCount };
+}
+// src/context.ts
+import { createContext, useContext, createElement } from "react";
+var FormContext = createContext(null);
+function FormProvider({
+  form,
+  children
+}) {
+  return createElement(FormContext.Provider, { value: form }, children);
+}
+function useFormContext() {
+  return useContext(FormContext);
+}
+// src/components.ts
+import { createElement as createElement2 } from "react";
+
+// src/a11y.ts
+var idCounter = 0;
+function generateA11yId(prefix = "ereo") {
+  return `${prefix}-${++idCounter}`;
+}
+function getFieldA11y(name, state) {
+  const attrs = {};
+  if (state.errors.length > 0 && state.touched) {
+    attrs["aria-invalid"] = true;
+    attrs["aria-describedby"] = `${name}-error`;
+  }
+  return attrs;
+}
+function getErrorA11y(name) {
+  return {
+    id: `${name}-error`,
+    role: "alert",
+    "aria-live": "polite"
+  };
+}
+function getLabelA11y(name, opts) {
+  return {
+    htmlFor: name,
+    id: opts?.id ?? `${name}-label`
+  };
+}
+function getDescriptionA11y(name) {
+  return {
+    id: `${name}-description`
+  };
+}
+function getFieldsetA11y(name, _legend) {
+  return {
+    role: "group",
+    "aria-labelledby": `${name}-legend`
+  };
+}
+function getFieldWrapperA11y(name, state) {
+  const attrs = {};
+  attrs["data-field"] = name;
+  if (state.errors.length > 0 && state.touched) {
+    attrs["data-invalid"] = true;
+  }
+  return attrs;
+}
+function getFormA11y(id, opts) {
+  const attrs = {
+    id,
+    role: "form"
+  };
+  if (opts?.isSubmitting) {
+    attrs["aria-busy"] = true;
+  }
+  return attrs;
+}
+function getErrorSummaryA11y(formId) {
+  return {
+    role: "alert",
+    "aria-labelledby": `${formId}-error-summary`
+  };
+}
+function focusFirstError(form) {
+  if (typeof document === "undefined")
+    return;
+  const scrollBehavior = prefersReducedMotion() ? "auto" : "smooth";
+  const formStore = form;
+  if (formStore._fieldRefs) {
+    for (const [path, el] of formStore._fieldRefs) {
+      if (!el)
+        continue;
+      const errors = form.getErrors(path).get();
+      if (errors.length > 0) {
+        el.focus();
+        el.scrollIntoView({ behavior: scrollBehavior, block: "center" });
+        return;
+      }
+    }
+  }
+  const elements = document.querySelectorAll('[aria-invalid="true"]');
+  const first = elements[0];
+  if (first) {
+    first.focus();
+    first.scrollIntoView({ behavior: scrollBehavior, block: "center" });
+  }
+}
+function focusField(name) {
+  if (typeof document === "undefined")
+    return;
+  const scrollBehavior = prefersReducedMotion() ? "auto" : "smooth";
+  const el = document.querySelector(`[name="${name}"]`);
+  if (el) {
+    el.focus();
+    el.scrollIntoView({ behavior: scrollBehavior, block: "center" });
+  }
+}
+function trapFocus(container) {
+  if (typeof document === "undefined")
+    return () => {};
+  const focusableSelector = 'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
+  const handleKeydown = (e) => {
+    if (e.key !== "Tab")
+      return;
+    const focusable = container.querySelectorAll(focusableSelector);
+    if (focusable.length === 0)
+      return;
+    const first = focusable[0];
+    const last = focusable[focusable.length - 1];
+    if (e.shiftKey) {
+      if (document.activeElement === first) {
+        e.preventDefault();
+        last.focus();
+      }
+    } else {
+      if (document.activeElement === last) {
+        e.preventDefault();
+        first.focus();
+      }
+    }
+  };
+  container.addEventListener("keydown", handleKeydown);
+  return () => container.removeEventListener("keydown", handleKeydown);
+}
+var liveRegion = null;
+function getOrCreateLiveRegion() {
+  if (typeof document === "undefined") {
+    return { textContent: "" };
+  }
+  if (!liveRegion) {
+    liveRegion = document.createElement("div");
+    liveRegion.setAttribute("role", "status");
+    liveRegion.setAttribute("aria-live", "polite");
+    liveRegion.setAttribute("aria-atomic", "true");
+    liveRegion.style.position = "absolute";
+    liveRegion.style.width = "1px";
+    liveRegion.style.height = "1px";
+    liveRegion.style.padding = "0";
+    liveRegion.style.margin = "-1px";
+    liveRegion.style.overflow = "hidden";
+    liveRegion.style.clip = "rect(0, 0, 0, 0)";
+    liveRegion.style.whiteSpace = "nowrap";
+    liveRegion.style.borderWidth = "0";
+    document.body.appendChild(liveRegion);
+  }
+  return liveRegion;
+}
+function announce(message, priority = "polite") {
+  const region = getOrCreateLiveRegion();
+  region.setAttribute("aria-live", priority);
+  region.textContent = "";
+  requestAnimationFrame(() => {
+    region.textContent = message;
+  });
+}
+function cleanupLiveRegion() {
+  if (liveRegion && typeof document !== "undefined") {
+    liveRegion.remove();
+    liveRegion = null;
+  }
+}
+function announceErrors(errors, opts) {
+  const errorEntries = Object.entries(errors).filter(([_, msgs]) => msgs.length > 0);
+  if (errorEntries.length === 0)
+    return;
+  const prefix = opts?.prefix ?? "Form has errors:";
+  const messages = errorEntries.map(([field, msgs]) => `${field}: ${msgs[0]}`).join(". ");
+  announce(`${prefix} ${messages}`, "assertive");
+}
+function announceSubmitStatus(status, opts) {
+  switch (status) {
+    case "submitting":
+      announce(opts?.submittingMessage ?? "Submitting form...", "polite");
+      break;
+    case "success":
+      announce(opts?.successMessage ?? "Form submitted successfully.", "polite");
+      break;
+    case "error":
+      announce(opts?.errorMessage ?? "Form submission failed. Please check for errors.", "assertive");
+      break;
+  }
+}
+function prefersReducedMotion() {
+  if (typeof window === "undefined")
+    return false;
+  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function isScreenReaderActive() {
+  if (typeof window === "undefined")
+    return false;
+  return document.querySelector('[role="application"]') !== null || window.navigator.userAgent.includes("NVDA") || window.navigator.userAgent.includes("JAWS");
+}
+
+// src/components.ts
+function inferInputType(name, explicitType) {
+  if (explicitType)
+    return explicitType;
+  const lastSegment = name.split(".").pop().toLowerCase();
+  if (lastSegment.includes("email"))
+    return "email";
+  if (lastSegment.includes("password"))
+    return "password";
+  if (lastSegment.includes("phone") || lastSegment.includes("tel"))
+    return "tel";
+  if (lastSegment.includes("url") || lastSegment.includes("website"))
+    return "url";
+  if (lastSegment.includes("date"))
+    return "date";
+  if (lastSegment.includes("time"))
+    return "time";
+  if (lastSegment.includes("number") || lastSegment.includes("age") || lastSegment.includes("quantity"))
+    return "number";
+  if (lastSegment.includes("search"))
+    return "search";
+  return "text";
+}
+function inferRequired(form, name, explicit) {
+  if (explicit !== undefined)
+    return explicit;
+  const opts = form.getFieldOptions?.(name);
+  if (!opts?.validate)
+    return false;
+  const validators = Array.isArray(opts.validate) ? opts.validate : [opts.validate];
+  return validators.some((v) => v._isRequired);
+}
+function Field(props) {
+  const contextForm = useFormContext();
+  const form = props.form ?? contextForm;
+  if (!form)
+    throw new Error("Field requires a form prop or FormProvider");
+  const field = useField(form, props.name);
+  const inputType = inferInputType(props.name, props.type);
+  const isRequired = inferRequired(form, props.name, props.required);
+  if (props.children) {
+    return props.children(field);
+  }
+  const children = [];
+  if (props.label) {
+    children.push(createElement2("label", { key: "label", ...getLabelA11y(props.name) }, props.label, isRequired ? createElement2("span", { key: "req", "aria-hidden": true }, " *") : null));
+  }
+  children.push(createElement2("input", {
+    key: "input",
+    ...field.inputProps,
+    type: inputType,
+    id: props.name,
+    required: isRequired,
+    disabled: props.disabled,
+    placeholder: props.placeholder,
+    className: props.className,
+    "aria-required": isRequired || undefined
+  }));
+  if (field.errors.length > 0 && field.touched) {
+    children.push(createElement2("div", { key: "error", ...getErrorA11y(props.name) }, field.errors[0]));
+  }
+  return createElement2("div", { "data-field": props.name }, ...children);
+}
+function TextareaField(props) {
+  const contextForm = useFormContext();
+  const form = props.form ?? contextForm;
+  if (!form)
+    throw new Error("TextareaField requires a form prop or FormProvider");
+  const field = useField(form, props.name);
+  const isRequired = inferRequired(form, props.name, props.required);
+  if (props.children) {
+    return props.children(field);
+  }
+  const children = [];
+  if (props.label) {
+    children.push(createElement2("label", { key: "label", ...getLabelA11y(props.name) }, props.label));
+  }
+  children.push(createElement2("textarea", {
+    key: "textarea",
+    ...field.inputProps,
+    id: props.name,
+    rows: props.rows,
+    cols: props.cols,
+    maxLength: props.maxLength,
+    required: isRequired,
+    disabled: props.disabled,
+    placeholder: props.placeholder,
+    className: props.className,
+    "aria-required": isRequired || undefined
+  }));
+  if (field.errors.length > 0 && field.touched) {
+    children.push(createElement2("div", { key: "error", ...getErrorA11y(props.name) }, field.errors[0]));
+  }
+  return createElement2("div", { "data-field": props.name }, ...children);
+}
+function SelectField(props) {
+  const contextForm = useFormContext();
+  const form = props.form ?? contextForm;
+  if (!form)
+    throw new Error("SelectField requires a form prop or FormProvider");
+  const field = useField(form, props.name);
+  const isRequired = inferRequired(form, props.name, props.required);
+  if (props.children) {
+    return props.children(field);
+  }
+  const children = [];
+  if (props.label) {
+    children.push(createElement2("label", { key: "label", ...getLabelA11y(props.name) }, props.label));
+  }
+  const options = props.options.map((opt, i) => createElement2("option", { key: opt.value ?? i, value: opt.value, disabled: opt.disabled }, opt.label));
+  children.push(createElement2("select", {
+    key: "select",
+    ...field.inputProps,
+    id: props.name,
+    multiple: props.multiple,
+    required: isRequired,
+    disabled: props.disabled,
+    className: props.className,
+    "aria-required": isRequired || undefined
+  }, ...options));
+  if (field.errors.length > 0 && field.touched) {
+    children.push(createElement2("div", { key: "error", ...getErrorA11y(props.name) }, field.errors[0]));
+  }
+  return createElement2("div", { "data-field": props.name }, ...children);
+}
+function FieldArrayComponent(props) {
+  const contextForm = useFormContext();
+  const form = props.form ?? contextForm;
+  if (!form)
+    throw new Error("FieldArray requires a form prop or FormProvider");
+  const helpers = useFieldArray(form, props.name);
+  return props.children(helpers);
+}
+// src/validators.ts
+function required(msg = "This field is required") {
+  const fn = (value) => {
+    if (value === null || value === undefined || value === "")
+      return msg;
+    if (Array.isArray(value) && value.length === 0)
+      return msg;
+    return;
+  };
+  fn._isRequired = true;
+  return fn;
+}
+function email(msg = "Invalid email address") {
+  return (value) => {
+    if (!value)
+      return;
+    const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return re.test(String(value)) ? undefined : msg;
+  };
+}
+function url(msg = "Invalid URL") {
+  return (value) => {
+    if (!value)
+      return;
+    try {
+      new URL(String(value));
+      return;
+    } catch {
+      return msg;
+    }
+  };
+}
+function date(msg = "Invalid date") {
+  return (value) => {
+    if (!value)
+      return;
+    const d = new Date(String(value));
+    return isNaN(d.getTime()) ? msg : undefined;
+  };
+}
+function phone(msg = "Invalid phone number") {
+  return (value) => {
+    if (!value)
+      return;
+    const str = String(value);
+    const re = /^\+?[\d\s\-().]{7,}$/;
+    const digitCount = (str.match(/\d/g) || []).length;
+    return re.test(str) && digitCount >= 7 ? undefined : msg;
+  };
+}
+function minLength(n, msg) {
+  return (value) => {
+    if (!value)
+      return;
+    return String(value).length >= n ? undefined : msg ?? `Must be at least ${n} characters`;
+  };
+}
+function maxLength(n, msg) {
+  return (value) => {
+    if (!value)
+      return;
+    return String(value).length <= n ? undefined : msg ?? `Must be at most ${n} characters`;
+  };
+}
+function min(n, msg) {
+  return (value) => {
+    if (value === null || value === undefined || value === "")
+      return;
+    return Number(value) >= n ? undefined : msg ?? `Must be at least ${n}`;
+  };
+}
+function max(n, msg) {
+  return (value) => {
+    if (value === null || value === undefined || value === "")
+      return;
+    return Number(value) <= n ? undefined : msg ?? `Must be at most ${n}`;
+  };
+}
+function pattern(regex, msg = "Invalid format") {
+  return (value) => {
+    if (!value)
+      return;
+    return regex.test(String(value)) ? undefined : msg;
+  };
+}
+function number(msg = "Must be a number") {
+  return (value) => {
+    if (value === null || value === undefined || value === "")
+      return;
+    return isNaN(Number(value)) ? msg : undefined;
+  };
+}
+function integer(msg = "Must be an integer") {
+  return (value) => {
+    if (value === null || value === undefined || value === "")
+      return;
+    return Number.isInteger(Number(value)) ? undefined : msg;
+  };
+}
+function positive(msg = "Must be a positive number") {
+  return (value) => {
+    if (value === null || value === undefined || value === "")
+      return;
+    return Number(value) > 0 ? undefined : msg;
+  };
+}
+function custom(fn, msg) {
+  return (value) => {
+    const result = fn(value);
+    if (result !== undefined)
+      return result;
+    return;
+  };
+}
+function async(fn, opts) {
+  const validator = (value) => fn(value);
+  validator._isAsync = true;
+  if (opts?.debounce)
+    validator._debounce = opts.debounce;
+  return validator;
+}
+function matches(otherField, msg) {
+  const validator = (value, context) => {
+    if (!context)
+      return;
+    const other = context.getValue(otherField);
+    return value === other ? undefined : msg ?? `Must match ${otherField}`;
+  };
+  validator._crossField = true;
+  return validator;
+}
+function oneOf(values, msg) {
+  return (value) => {
+    if (value === null || value === undefined || value === "")
+      return;
+    return values.includes(value) ? undefined : msg ?? `Must be one of: ${values.join(", ")}`;
+  };
+}
+function notOneOf(values, msg) {
+  return (value) => {
+    if (value === null || value === undefined || value === "")
+      return;
+    return !values.includes(value) ? undefined : msg ?? `Must not be one of: ${values.join(", ")}`;
+  };
+}
+function fileSize(maxBytes, msg) {
+  return (value) => {
+    if (!value)
+      return;
+    const file = value;
+    if (!file.size)
+      return;
+    return file.size <= maxBytes ? undefined : msg ?? `File must be less than ${Math.round(maxBytes / 1024)}KB`;
+  };
+}
+function fileType(types, msg) {
+  return (value) => {
+    if (!value)
+      return;
+    const file = value;
+    if (!file.type)
+      return;
+    return types.some((t) => file.type.includes(t)) ? undefined : msg ?? `File type must be: ${types.join(", ")}`;
+  };
+}
+function compose(...rules) {
+  const hasAsync = rules.some((r) => r._isAsync);
+  const fn = hasAsync ? async (value, context) => {
+    for (const rule of rules) {
+      const result = await rule(value, context);
+      if (result)
+        return result;
+    }
+    return;
+  } : (value, context) => {
+    for (const rule of rules) {
+      const result = rule(value, context);
+      if (result)
+        return result;
+    }
+    return;
+  };
+  fn._isAsync = hasAsync;
+  fn._isRequired = rules.some((r) => r._isRequired);
+  fn._crossField = rules.some((r) => r._crossField);
+  const maxDebounce = rules.reduce((max2, r) => Math.max(max2, r._debounce ?? 0), 0);
+  if (maxDebounce > 0)
+    fn._debounce = maxDebounce;
+  return fn;
+}
+function when(condition, rule) {
+  const fn = rule._isAsync ? async (value, context) => {
+    if (!condition(value, context))
+      return;
+    return rule(value, context);
+  } : (value, context) => {
+    if (!condition(value, context))
+      return;
+    return rule(value, context);
+  };
+  fn._isAsync = rule._isAsync;
+  fn._crossField = rule._crossField;
+  return fn;
+}
+var v = {
+  required,
+  email,
+  url,
+  date,
+  phone,
+  minLength,
+  maxLength,
+  min,
+  max,
+  pattern,
+  number,
+  integer,
+  positive,
+  custom,
+  async,
+  matches,
+  oneOf,
+  notOneOf,
+  fileSize,
+  fileType,
+  compose,
+  when
+};
+// src/schema.ts
+function zodAdapter(zodSchema) {
+  return {
+    parse: (data) => zodSchema.parse(data),
+    safeParse: (data) => {
+      const result = zodSchema.safeParse(data);
+      if (result.success) {
+        return { success: true, data: result.data };
+      }
+      return {
+        success: false,
+        error: {
+          issues: result.error.issues.map((issue) => ({
+            path: issue.path,
+            message: issue.message
+          }))
+        }
+      };
+    }
+  };
+}
+function valibotAdapter(schema, parse, safeParse) {
+  return {
+    parse: (data) => parse(schema, data),
+    safeParse: (data) => {
+      const result = safeParse(schema, data);
+      if (result.success) {
+        return { success: true, data: result.output };
+      }
+      return {
+        success: false,
+        error: {
+          issues: (result.issues || []).map((issue) => ({
+            path: (issue.path || []).map((p) => p.key),
+            message: issue.message
+          }))
+        }
+      };
+    }
+  };
+}
+function createSchemaValidator(opts) {
+  return {
+    parse: (data) => {
+      const result = opts.validate(data);
+      if (result.success)
+        return result.data;
+      throw new Error("Validation failed");
+    },
+    safeParse: (data) => {
+      const result = opts.validate(data);
+      if (result.success) {
+        return { success: true, data: result.data };
+      }
+      return {
+        success: false,
+        error: {
+          issues: Object.entries(result.errors).flatMap(([path, messages]) => messages.map((message) => ({
+            path: path.split("."),
+            message
+          })))
+        }
+      };
+    }
+  };
+}
+var EREO_SCHEMA_MARKER = Symbol("ereo-schema");
+function ereoSchema(definition) {
+  const schema = {
+    [EREO_SCHEMA_MARKER]: true,
+    parse: (data) => {
+      const result = schema.safeParse(data);
+      if (result.success)
+        return result.data;
+      const messages = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`);
+      throw new Error(`Validation failed:
+${messages.join(`
+`)}`);
+    },
+    safeParse: (data) => {
+      const context = {
+        getValue: (path) => getPath(data, path),
+        getValues: () => data
+      };
+      const errors = validateDefinition(definition, data, "", context);
+      if (errors.length === 0) {
+        return { success: true, data };
+      }
+      return {
+        success: false,
+        error: { issues: errors }
+      };
+    }
+  };
+  return schema;
+}
+function validateDefinition(definition, data, basePath, context) {
+  const issues = [];
+  for (const [key, rule] of Object.entries(definition)) {
+    const path = basePath ? `${basePath}.${key}` : key;
+    const value = data?.[key];
+    if (typeof rule === "function") {
+      if (rule._isAsync)
+        continue;
+      const result = rule(value, context);
+      if (typeof result === "string") {
+        issues.push({ path: path.split("."), message: result });
+      }
+    } else if (Array.isArray(rule)) {
+      for (const validator of rule) {
+        if (typeof validator === "function") {
+          if (validator._isAsync)
+            continue;
+          const result = validator(value, context);
+          if (typeof result === "string") {
+            issues.push({ path: path.split("."), message: result });
+            break;
+          }
+        }
+      }
+    } else if (typeof rule === "object" && rule !== null) {
+      const nested = validateDefinition(rule, value, path, context);
+      issues.push(...nested);
+    }
+  }
+  return issues;
+}
+function isEreoSchema(value) {
+  return value !== null && typeof value === "object" && EREO_SCHEMA_MARKER in value;
+}
+function formDataToObject(formData, opts) {
+  const result = {};
+  const arrayFields = new Set(opts?.arrays ?? []);
+  for (const [key, value] of formData.entries()) {
+    const isArray = key.endsWith("[]") || arrayFields.has(key);
+    const cleanKey = key.replace(/\[\]$/, "");
+    const coerced = opts?.coerce !== false ? coerceValue(value) : value;
+    if (isArray) {
+      if (!result[cleanKey])
+        result[cleanKey] = [];
+      result[cleanKey].push(coerced);
+    } else if (cleanKey.includes(".") || cleanKey.includes("[")) {
+      setNestedValue(result, cleanKey, coerced);
+    } else {
+      result[cleanKey] = coerced;
+    }
+  }
+  return result;
+}
+function coerceValue(value) {
+  if (value instanceof File)
+    return value;
+  const str = String(value);
+  if (str === "true")
+    return true;
+  if (str === "false")
+    return false;
+  if (str === "null")
+    return null;
+  if (str === "")
+    return "";
+  const trimmed = str.trim();
+  if (trimmed !== "" && !/^0\d/.test(trimmed)) {
+    const num = Number(trimmed);
+    if (!isNaN(num))
+      return num;
+  }
+  if (/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2})?)?$/.test(str)) {
+    const d = new Date(str);
+    if (!isNaN(d.getTime()))
+      return d.toISOString();
+  }
+  return str;
+}
+function setNestedValue(obj, path, value) {
+  const segments = [];
+  let current = "";
+  for (let i = 0;i < path.length; i++) {
+    const char = path[i];
+    if (char === ".") {
+      if (current) {
+        segments.push(current);
+        current = "";
+      }
+    } else if (char === "[") {
+      if (current) {
+        segments.push(current);
+        current = "";
+      }
+      const close = path.indexOf("]", i);
+      if (close !== -1) {
+        const idx = path.slice(i + 1, close);
+        const num = parseInt(idx, 10);
+        segments.push(!isNaN(num) ? num : idx);
+        i = close;
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current)
+    segments.push(current);
+  let target = obj;
+  for (let i = 0;i < segments.length - 1; i++) {
+    const seg = segments[i];
+    const nextSeg = segments[i + 1];
+    if (target[seg] === undefined) {
+      target[seg] = typeof nextSeg === "number" ? [] : {};
+    }
+    target = target[seg];
+  }
+  target[segments[segments.length - 1]] = value;
+}
+// src/action.ts
+import { createElement as createElement3, useCallback as useCallback2, useRef as useRef2, useEffect as useEffect2, useState } from "react";
+import { batch as batch2 } from "@ereo/state";
+function createFormAction(opts) {
+  return async (request) => {
+    try {
+      const contentType = request.headers.get("Content-Type") || "";
+      let raw;
+      if (contentType.includes("application/json")) {
+        raw = await request.json();
+      } else if (contentType.includes("multipart/form-data") || contentType.includes("application/x-www-form-urlencoded")) {
+        const formData = await request.formData();
+        raw = formDataToObject(formData);
+      } else {
+        try {
+          const text = await request.text();
+          raw = JSON.parse(text);
+        } catch {
+          return { success: false, errors: { "": ["Invalid request body"] } };
+        }
+      }
+      let values;
+      if (opts.schema) {
+        if (opts.schema.safeParse) {
+          const result = opts.schema.safeParse(raw);
+          if (!result.success) {
+            const errors = {};
+            for (const issue of result.error.issues) {
+              const path = issue.path.join(".");
+              if (!errors[path])
+                errors[path] = [];
+              errors[path].push(issue.message);
+            }
+            return { success: false, errors };
+          }
+          values = result.data;
+        } else {
+          try {
+            values = opts.schema.parse(raw);
+          } catch (e) {
+            if (e?.issues) {
+              const errors = {};
+              for (const issue of e.issues) {
+                const path = issue.path?.join(".") ?? "";
+                if (!errors[path])
+                  errors[path] = [];
+                errors[path].push(issue.message);
+              }
+              return { success: false, errors };
+            }
+            return { success: false, errors: { "": [e?.message ?? "Validation failed"] } };
+          }
+        }
+      } else {
+        values = raw;
+      }
+      const data = await opts.handler(values);
+      return { success: true, data };
+    } catch (error) {
+      if (opts.onError) {
+        return opts.onError(error);
+      }
+      return {
+        success: false,
+        errors: { "": [error instanceof Error ? error.message : "Server error"] }
+      };
+    }
+  };
+}
+function ActionForm(props) {
+  const {
+    form,
+    action,
+    method = "post",
+    onSuccess,
+    onError,
+    children,
+    className,
+    id,
+    encType = "application/json"
+  } = props;
+  const abortRef = useRef2(null);
+  const generationRef = useRef2(0);
+  useEffect2(() => {
+    return () => {
+      abortRef.current?.abort();
+    };
+  }, []);
+  const handleSubmit = useCallback2(async (e) => {
+    e.preventDefault();
+    abortRef.current?.abort();
+    const generation = ++generationRef.current;
+    const controller = new AbortController;
+    abortRef.current = controller;
+    const valid = await form.validate();
+    if (generation !== generationRef.current)
+      return;
+    if (!valid) {
+      focusFirstError(form);
+      announceErrors({}, { prefix: "Please fix the following errors:" });
+      return;
+    }
+    const values = form.getValues();
+    batch2(() => {
+      form.isSubmitting.set(true);
+      form.submitState.set("submitting");
+    });
+    announceSubmitStatus("submitting");
+    try {
+      let result;
+      if (typeof action === "function") {
+        result = await action(values);
+      } else {
+        const isMultipart = encType === "multipart/form-data";
+        const response = await fetch(action, {
+          method: method.toUpperCase(),
+          headers: isMultipart ? undefined : { "Content-Type": "application/json" },
+          body: isMultipart ? form.toFormData() : JSON.stringify(values),
+          signal: controller.signal
+        });
+        result = await response.json();
+      }
+      if (generation !== generationRef.current)
+        return;
+      if (result.success) {
+        batch2(() => {
+          form.isSubmitting.set(false);
+          form.submitState.set("success");
+          form.submitCount.update((c) => c + 1);
+        });
+        announceSubmitStatus("success");
+        onSuccess?.(result.data);
+      } else {
+        batch2(() => {
+          form.isSubmitting.set(false);
+          form.submitState.set("error");
+        });
+        announceSubmitStatus("error");
+        if (result.errors) {
+          for (const [path, errors] of Object.entries(result.errors)) {
+            if (path) {
+              form.setErrors(path, errors);
+            } else {
+              form.setFormErrors(errors);
+            }
+          }
+          focusFirstError(form);
+          announceErrors(result.errors);
+          onError?.(result.errors);
+        }
+      }
+    } catch (error) {
+      if (generation !== generationRef.current || controller.signal.aborted)
+        return;
+      batch2(() => {
+        form.isSubmitting.set(false);
+        form.submitState.set("error");
+      });
+      announceSubmitStatus("error");
+      const errorMsg = error instanceof Error ? error.message : "Submission failed";
+      form.setFormErrors([errorMsg]);
+      onError?.({ "": [errorMsg] });
+    }
+  }, [form, action, method, encType, onSuccess, onError]);
+  return createElement3("form", {
+    id,
+    className,
+    method,
+    action: typeof action === "string" ? action : undefined,
+    onSubmit: handleSubmit,
+    noValidate: true
+  }, children);
+}
+function useFormAction(opts) {
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [result, setResult] = useState(null);
+  const abortRef = useRef2(null);
+  const cancel = useCallback2(() => {
+    abortRef.current?.abort();
+    abortRef.current = null;
+    setIsSubmitting(false);
+  }, []);
+  const submit = useCallback2(async (values) => {
+    cancel();
+    const controller = new AbortController;
+    abortRef.current = controller;
+    setIsSubmitting(true);
+    try {
+      let actionResult;
+      if (typeof opts.action === "function") {
+        actionResult = await opts.action(values);
+      } else {
+        const isMultipart = opts.encType === "multipart/form-data";
+        const response = await fetch(opts.action, {
+          method: (opts.method ?? "POST").toUpperCase(),
+          headers: isMultipart ? undefined : { "Content-Type": "application/json" },
+          body: isMultipart ? objectToFormData(values) : JSON.stringify(values),
+          signal: controller.signal
+        });
+        actionResult = await response.json();
+      }
+      if (!controller.signal.aborted) {
+        setResult(actionResult);
+        setIsSubmitting(false);
+      }
+      return actionResult;
+    } catch (error) {
+      if (!controller.signal.aborted) {
+        const errorResult = {
+          success: false,
+          errors: {
+            "": [error instanceof Error ? error.message : "Request failed"]
+          }
+        };
+        setResult(errorResult);
+        setIsSubmitting(false);
+        return errorResult;
+      }
+      return { success: false, errors: { "": ["Request cancelled"] } };
+    }
+  }, [opts.action, opts.method, opts.encType, cancel]);
+  return { submit, cancel, isSubmitting, result };
+}
+function parseActionResult(response) {
+  if (response === null || response === undefined) {
+    return { success: false, errors: { "": ["Empty response"] } };
+  }
+  if (typeof response === "object") {
+    const obj = response;
+    if ("success" in obj) {
+      return obj;
+    }
+    if ("error" in obj) {
+      const error = obj.error;
+      return {
+        success: false,
+        errors: {
+          "": [typeof error === "string" ? error : "Unknown error"]
+        }
+      };
+    }
+    if ("errors" in obj) {
+      return {
+        success: false,
+        errors: obj.errors
+      };
+    }
+    if ("data" in obj) {
+      return { success: true, data: obj.data };
+    }
+  }
+  return { success: true, data: response };
+}
+function objectToFormData(values) {
+  const fd = new FormData;
+  if (values === null || typeof values !== "object")
+    return fd;
+  const flat = flattenToPaths(values);
+  for (const [path, value] of flat) {
+    if (value instanceof File) {
+      fd.append(path, value);
+    } else if (typeof value !== "object" || value === null) {
+      fd.append(path, String(value ?? ""));
+    }
+  }
+  return fd;
+}
+// src/wizard.ts
+import {
+  createElement as createElement4,
+  createContext as createContext2,
+  useContext as useContext2,
+  useRef as useRef3,
+  useCallback as useCallback3,
+  useEffect as useEffect3,
+  useMemo as useMemo3
+} from "react";
+import { signal as signal3, batch as batch3 } from "@ereo/state";
+import { useSignal as useSignal2 } from "@ereo/state";
+function createWizard(config) {
+  const form = new FormStore(config.form);
+  const currentStep = signal3(0);
+  const completedSteps = signal3(new Set);
+  const { steps, persist, persistKey = "ereo-wizard" } = config;
+  if (persist && typeof window !== "undefined") {
+    try {
+      const storage = persist === "localStorage" ? localStorage : sessionStorage;
+      const saved = storage.getItem(persistKey);
+      if (saved) {
+        const parsed = JSON.parse(saved);
+        if (parsed.values) {
+          form.resetTo(parsed.values);
+        }
+        if (typeof parsed.step === "number") {
+          currentStep.set(parsed.step);
+        }
+        if (parsed.completed) {
+          completedSteps.set(new Set(parsed.completed));
+        }
+      }
+    } catch {}
+  }
+  let persistTimer = null;
+  function persistState() {
+    if (!persist || typeof window === "undefined")
+      return;
+    if (persistTimer)
+      clearTimeout(persistTimer);
+    persistTimer = setTimeout(() => {
+      try {
+        const storage = persist === "localStorage" ? localStorage : sessionStorage;
+        storage.setItem(persistKey, JSON.stringify({
+          values: form._getCurrentValues(),
+          step: currentStep.get(),
+          completed: Array.from(completedSteps.get())
+        }));
+      } catch {}
+    }, 300);
+  }
+  const unsubForm = form.subscribe(persistState);
+  const unsubStep = currentStep.subscribe(persistState);
+  const unsubCompleted = completedSteps.subscribe(persistState);
+  function getState() {
+    const step = currentStep.get();
+    const stepConfig = steps[step];
+    return {
+      currentStep: step,
+      currentStepId: stepConfig?.id ?? "",
+      completedSteps: completedSteps.get(),
+      totalSteps: steps.length,
+      isFirst: step === 0,
+      isLast: step === steps.length - 1,
+      progress: steps.length > 1 ? step / (steps.length - 1) : 1
+    };
+  }
+  async function validateCurrentStep() {
+    const step = currentStep.get();
+    const stepConfig = steps[step];
+    if (!stepConfig)
+      return true;
+    if (stepConfig.fields) {
+      for (const field of stepConfig.fields) {
+        form.setTouched(field, true);
+      }
+    }
+    if (stepConfig.validate) {
+      const valid = await stepConfig.validate();
+      if (!valid)
+        return false;
+    }
+    if (stepConfig.fields && stepConfig.fields.length > 0) {
+      const result = await form._validationEngine.validateFields(stepConfig.fields);
+      return result.success;
+    }
+    return true;
+  }
+  async function next() {
+    const valid = await validateCurrentStep();
+    if (!valid)
+      return false;
+    const step = currentStep.get();
+    const stepConfig = steps[step];
+    batch3(() => {
+      const completed = new Set(completedSteps.get());
+      if (stepConfig)
+        completed.add(stepConfig.id);
+      completedSteps.set(completed);
+      if (step < steps.length - 1) {
+        currentStep.set(step + 1);
+      }
+    });
+    return true;
+  }
+  function prev() {
+    const step = currentStep.get();
+    if (step > 0) {
+      currentStep.set(step - 1);
+    }
+  }
+  function goTo(stepIdOrIndex) {
+    if (typeof stepIdOrIndex === "number") {
+      if (stepIdOrIndex >= 0 && stepIdOrIndex < steps.length) {
+        currentStep.set(stepIdOrIndex);
+      }
+    } else {
+      const idx = steps.findIndex((s) => s.id === stepIdOrIndex);
+      if (idx !== -1) {
+        currentStep.set(idx);
+      }
+    }
+  }
+  async function submit() {
+    const valid = await validateCurrentStep();
+    if (!valid)
+      return;
+    const step = currentStep.get();
+    const stepConfig = steps[step];
+    if (stepConfig) {
+      const completed = new Set(completedSteps.get());
+      completed.add(stepConfig.id);
+      completedSteps.set(completed);
+    }
+    if (config.onComplete) {
+      await form.submitWith(config.onComplete);
+    } else {
+      await form.handleSubmit();
+    }
+    if (persist && typeof window !== "undefined") {
+      try {
+        const storage = persist === "localStorage" ? localStorage : sessionStorage;
+        storage.removeItem(persistKey);
+      } catch {}
+    }
+  }
+  function reset() {
+    if (persistTimer) {
+      clearTimeout(persistTimer);
+      persistTimer = null;
+    }
+    batch3(() => {
+      form.reset();
+      currentStep.set(0);
+      completedSteps.set(new Set);
+    });
+    if (persist && typeof window !== "undefined") {
+      try {
+        const storage = persist === "localStorage" ? localStorage : sessionStorage;
+        storage.removeItem(persistKey);
+      } catch {}
+    }
+  }
+  function dispose() {
+    unsubForm();
+    unsubStep();
+    unsubCompleted();
+    if (persistTimer) {
+      clearTimeout(persistTimer);
+      persistTimer = null;
+    }
+  }
+  return {
+    form,
+    currentStep,
+    completedSteps,
+    get state() {
+      return getState();
+    },
+    next,
+    prev,
+    goTo,
+    submit,
+    reset,
+    dispose,
+    getStepConfig: (index) => steps[index],
+    canGoNext: () => currentStep.get() < steps.length - 1,
+    canGoPrev: () => currentStep.get() > 0
+  };
+}
+function useWizard(config) {
+  const wizardRef = useRef3(null);
+  if (!wizardRef.current) {
+    wizardRef.current = createWizard(config);
+  }
+  useEffect3(() => {
+    return () => {
+      wizardRef.current?.dispose();
+    };
+  }, []);
+  const wizard = wizardRef.current;
+  const step = useSignal2(wizard.currentStep);
+  const completed = useSignal2(wizard.completedSteps);
+  const currentStepState = useMemo3(() => ({
+    currentStep: step,
+    currentStepId: config.steps[step]?.id ?? "",
+    completedSteps: completed,
+    totalSteps: config.steps.length,
+    isFirst: step === 0,
+    isLast: step === config.steps.length - 1,
+    progress: config.steps.length > 1 ? step / (config.steps.length - 1) : 1
+  }), [step, completed, config.steps]);
+  return { ...wizard, currentStepState };
+}
+var WizardContext = createContext2(null);
+function WizardProvider({
+  wizard,
+  children
+}) {
+  return createElement4(WizardContext.Provider, { value: wizard }, children);
+}
+function useWizardContext() {
+  return useContext2(WizardContext);
+}
+function WizardStep({
+  id,
+  wizard: wizardProp,
+  keepMounted = false,
+  children
+}) {
+  const contextWizard = useWizardContext();
+  const wizard = wizardProp ?? contextWizard;
+  if (!wizard)
+    throw new Error("WizardStep requires a wizard prop or WizardProvider");
+  const currentStep = useSignal2(wizard.currentStep);
+  const config = wizard.getStepConfig(currentStep);
+  const isActive = config?.id === id;
+  if (!isActive && !keepMounted)
+    return null;
+  return createElement4("div", {
+    "data-wizard-step": id,
+    "data-active": isActive,
+    style: isActive ? undefined : { display: "none" },
+    role: "tabpanel",
+    "aria-hidden": !isActive
+  }, children);
+}
+function WizardProgress({
+  wizard: wizardProp,
+  renderStep
+}) {
+  const contextWizard = useWizardContext();
+  const wizard = wizardProp ?? contextWizard;
+  if (!wizard)
+    throw new Error("WizardProgress requires a wizard prop or WizardProvider");
+  const currentStep = useSignal2(wizard.currentStep);
+  const completed = useSignal2(wizard.completedSteps);
+  const state = wizard.state;
+  const steps = [];
+  for (let i = 0;i < state.totalSteps; i++) {
+    const stepConfig = wizard.getStepConfig(i);
+    if (!stepConfig)
+      continue;
+    const isActive = i === currentStep;
+    const isCompleted = completed.has(stepConfig.id);
+    if (renderStep) {
+      steps.push(renderStep(stepConfig, i, { isActive, isCompleted }));
+    } else {
+      steps.push(createElement4("div", {
+        key: stepConfig.id,
+        "data-step": stepConfig.id,
+        "data-active": isActive,
+        "data-completed": isCompleted,
+        role: "tab",
+        "aria-selected": isActive,
+        style: {
+          fontWeight: isActive ? "bold" : "normal",
+          opacity: isCompleted || isActive ? 1 : 0.5
+        }
+      }, stepConfig.id));
+    }
+  }
+  return createElement4("div", {
+    role: "tablist",
+    "aria-label": "Form steps",
+    "data-wizard-progress": true
+  }, ...steps);
+}
+function WizardNavigation({
+  wizard: wizardProp,
+  backLabel = "Back",
+  nextLabel = "Next",
+  submitLabel = "Submit"
+}) {
+  const contextWizard = useWizardContext();
+  const wizard = wizardProp ?? contextWizard;
+  if (!wizard)
+    throw new Error("WizardNavigation requires a wizard prop or WizardProvider");
+  const currentStep = useSignal2(wizard.currentStep);
+  const state = wizard.state;
+  const handleBack = useCallback3(() => wizard.prev(), [wizard]);
+  const handleNext = useCallback3(() => wizard.next(), [wizard]);
+  const handleSubmit = useCallback3(() => wizard.submit(), [wizard]);
+  return createElement4("div", { "data-wizard-navigation": true }, !state.isFirst ? createElement4("button", { type: "button", onClick: handleBack }, backLabel) : null, state.isLast ? createElement4("button", { type: "button", onClick: handleSubmit }, submitLabel) : createElement4("button", { type: "button", onClick: handleNext }, nextLabel));
+}
+// src/composition.ts
+function deepMergeObjects(a, b) {
+  const result = { ...a };
+  for (const key of Object.keys(b)) {
+    const aVal = a[key];
+    const bVal = b[key];
+    if (aVal !== null && bVal !== null && aVal !== undefined && bVal !== undefined && typeof aVal === "object" && typeof bVal === "object" && !Array.isArray(aVal) && !Array.isArray(bVal)) {
+      result[key] = deepMergeObjects(aVal, bVal);
+    } else {
+      result[key] = bVal;
+    }
+  }
+  return result;
+}
+function mergeFormConfigs(configA, configB) {
+  const mergedValidators = {};
+  if (configA.validators) {
+    for (const [key, val] of Object.entries(configA.validators)) {
+      if (val)
+        mergedValidators[key] = val;
+    }
+  }
+  if (configB.validators) {
+    for (const [key, val] of Object.entries(configB.validators)) {
+      if (val) {
+        const existing = mergedValidators[key];
+        if (existing) {
+          const existingArr = Array.isArray(existing) ? existing : [existing];
+          const newArr = Array.isArray(val) ? val : [val];
+          mergedValidators[key] = [...existingArr, ...newArr];
+        } else {
+          mergedValidators[key] = val;
+        }
+      }
+    }
+  }
+  return {
+    defaultValues: deepMergeObjects(configA.defaultValues, configB.defaultValues),
+    onSubmit: configB.onSubmit ?? configA.onSubmit,
+    schema: configB.schema ?? configA.schema,
+    validators: Object.keys(mergedValidators).length > 0 ? mergedValidators : undefined,
+    validateOn: configB.validateOn ?? configA.validateOn,
+    validateOnMount: configB.validateOnMount ?? configA.validateOnMount,
+    resetOnSubmit: configB.resetOnSubmit ?? configA.resetOnSubmit
+  };
+}
+function composeSchemas(prefix1, schema1, prefix2, schema2) {
+  return {
+    parse(data) {
+      const obj = data ?? {};
+      const result1 = schema1.parse(obj[prefix1]);
+      const result2 = schema2.parse(obj[prefix2]);
+      return { [prefix1]: result1, [prefix2]: result2 };
+    },
+    safeParse(data) {
+      const allIssues = [];
+      let result = {};
+      const obj = data ?? {};
+      if (schema1.safeParse) {
+        const r1 = schema1.safeParse(obj[prefix1]);
+        if (r1.success) {
+          result[prefix1] = r1.data;
+        } else {
+          for (const issue of r1.error.issues) {
+            allIssues.push({
+              path: [prefix1, ...issue.path],
+              message: issue.message
+            });
+          }
+        }
+      } else {
+        try {
+          result[prefix1] = schema1.parse(obj[prefix1]);
+        } catch (e) {
+          if (e?.issues) {
+            for (const issue of e.issues) {
+              allIssues.push({
+                path: [prefix1, ...issue.path ?? []],
+                message: issue.message
+              });
+            }
+          } else {
+            throw e;
+          }
+        }
+      }
+      if (schema2.safeParse) {
+        const r2 = schema2.safeParse(obj[prefix2]);
+        if (r2.success) {
+          result[prefix2] = r2.data;
+        } else {
+          for (const issue of r2.error.issues) {
+            allIssues.push({
+              path: [prefix2, ...issue.path],
+              message: issue.message
+            });
+          }
+        }
+      } else {
+        try {
+          result[prefix2] = schema2.parse(obj[prefix2]);
+        } catch (e) {
+          if (e?.issues) {
+            for (const issue of e.issues) {
+              allIssues.push({
+                path: [prefix2, ...issue.path ?? []],
+                message: issue.message
+              });
+            }
+          } else {
+            throw e;
+          }
+        }
+      }
+      if (allIssues.length > 0) {
+        return { success: false, error: { issues: allIssues } };
+      }
+      return { success: true, data: result };
+    }
+  };
+}
+export {
+  zodAdapter,
+  when,
+  valibotAdapter,
+  v,
+  useWizardContext,
+  useWizard,
+  useFormStatus,
+  useFormContext,
+  useFormAction,
+  useForm,
+  useFieldArray,
+  useField,
+  url,
+  trapFocus,
+  setPath,
+  required,
+  prefersReducedMotion,
+  positive,
+  phone,
+  pattern,
+  parsePath,
+  parseActionResult,
+  oneOf,
+  number,
+  notOneOf,
+  minLength,
+  min,
+  mergeFormConfigs,
+  maxLength,
+  max,
+  matches,
+  isScreenReaderActive,
+  isEreoSchema,
+  integer,
+  getPath,
+  getLabelA11y,
+  getFormA11y,
+  getFieldsetA11y,
+  getFieldWrapperA11y,
+  getFieldA11y,
+  getErrorSummaryA11y,
+  getErrorA11y,
+  getDescriptionA11y,
+  generateA11yId,
+  formDataToObject,
+  focusFirstError,
+  focusField,
+  flattenToPaths,
+  fileType,
+  fileSize,
+  ereoSchema,
+  email,
+  deepEqual,
+  deepClone,
+  date,
+  custom,
+  createWizard,
+  createValuesProxy,
+  createSchemaValidator,
+  createFormStore,
+  createFormAction,
+  composeSchemas,
+  compose,
+  cleanupLiveRegion,
+  async,
+  announceSubmitStatus,
+  announceErrors,
+  announce,
+  WizardStep,
+  WizardProvider,
+  WizardProgress,
+  WizardNavigation,
+  ValidationEngine,
+  TextareaField,
+  SelectField,
+  FormStore,
+  FormProvider,
+  FieldArrayComponent as FieldArray,
+  Field,
+  ActionForm
+};