@ereo/forms 0.1.23 → 0.1.24

package/dist/index.js

@@ -219,6 +219,7 @@ function flattenToPaths(obj, prefix = "") {
 var PROXY_MARKER = Symbol("ereo-form-proxy");
 function createValuesProxy(store, basePath = "", proxyCache) {
   const cache = proxyCache ?? new Map;
+  const s = store;
   if (basePath && cache.has(basePath)) {
     return cache.get(basePath);
   }
@@ -229,7 +230,7 @@ function createValuesProxy(store, basePath = "", proxyCache) {
       if (typeof prop === "symbol")
         return;
       const fullPath = basePath ? `${basePath}.${String(prop)}` : String(prop);
-      const value = store.getValue(fullPath);
+      const value = s.getValue(fullPath);
       if (value !== null && typeof value === "object") {
         return createValuesProxy(store, fullPath, cache);
       }
@@ -239,7 +240,7 @@ function createValuesProxy(store, basePath = "", proxyCache) {
       if (typeof prop === "symbol")
         return true;
       const fullPath = basePath ? `${basePath}.${String(prop)}` : String(prop);
-      store.setValue(fullPath, value);
+      s.setValue(fullPath, value);
       return true;
     },
     has(_target, prop) {
@@ -247,14 +248,14 @@ function createValuesProxy(store, basePath = "", proxyCache) {
         return true;
       if (typeof prop === "symbol")
         return false;
-      const obj = basePath ? store.getValue(basePath) : store.getValues();
+      const obj = basePath ? s.getValue(basePath) : s.getValues();
       if (obj !== null && typeof obj === "object") {
         return String(prop) in obj;
       }
       return false;
     },
     ownKeys() {
-      const obj = basePath ? store.getValue(basePath) : store.getValues();
+      const obj = basePath ? s.getValue(basePath) : s.getValues();
       if (obj !== null && typeof obj === "object") {
         return Object.keys(obj);
       }
@@ -263,14 +264,14 @@ function createValuesProxy(store, basePath = "", proxyCache) {
     getOwnPropertyDescriptor(_target, prop) {
       if (typeof prop === "symbol")
         return;
-      const obj = basePath ? store.getValue(basePath) : store.getValues();
+      const obj = basePath ? s.getValue(basePath) : s.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)
+          value: s.getValue(fullPath)
         };
       }
       return;
@@ -285,6 +286,267 @@ function createValuesProxy(store, basePath = "", proxyCache) {
 // src/validation-engine.ts
 import { signal } from "@ereo/state";
 
+// src/schema.ts
+function isStandardSchema(value) {
+  return value !== null && typeof value === "object" && "~standard" in value;
+}
+function normalizePath(path) {
+  if (!path)
+    return [];
+  return path.map((segment) => {
+    if (typeof segment === "object" && segment !== null && "key" in segment) {
+      return typeof segment.key === "number" ? segment.key : String(segment.key);
+    }
+    return typeof segment === "number" ? segment : String(segment);
+  });
+}
+function standardSchemaAdapter(schema) {
+  return {
+    parse: (data) => {
+      const result = schema["~standard"].validate(data);
+      if (result instanceof Promise) {
+        throw new Error("Async Standard Schema validation not supported in parse()");
+      }
+      if ("issues" in result && result.issues) {
+        const msgs = result.issues.map((i) => i.message).join(", ");
+        throw new Error(msgs);
+      }
+      return result.value;
+    },
+    safeParse: (data) => {
+      const result = schema["~standard"].validate(data);
+      if (result instanceof Promise) {
+        throw new Error("Async Standard Schema validation not supported in safeParse()");
+      }
+      if ("issues" in result && result.issues) {
+        return {
+          success: false,
+          error: {
+            issues: result.issues.map((issue) => ({
+              path: normalizePath(issue.path),
+              message: issue.message
+            }))
+          }
+        };
+      }
+      return { success: true, data: result.value };
+    }
+  };
+}
+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/validation-engine.ts
 class ValidationEngine {
   _store;
   _fieldValidations = new Map;
@@ -294,6 +556,8 @@ class ValidationEngine {
   _validatingSignals = new Map;
   _fieldGenerations = new Map;
   _validateAllController = null;
+  _dependents = new Map;
+  _validatingDependents = new Set;
   constructor(store) {
     this._store = store;
     const { validators } = store.config;
@@ -305,14 +569,36 @@ class ValidationEngine {
         }
       }
     }
+    const { dependencies } = store.config;
+    if (dependencies) {
+      for (const [dependent, sources] of Object.entries(dependencies)) {
+        if (sources) {
+          const sourceArr = Array.isArray(sources) ? sources : [sources];
+          for (const source of sourceArr) {
+            this._registerDependency(dependent, source);
+          }
+        }
+      }
+    }
   }
-  registerFieldValidators(path, validators, explicitTrigger) {
+  registerFieldValidators(path, validators, explicitTrigger, dependsOn) {
     const derivedTrigger = explicitTrigger ?? this._deriveValidateOn(validators);
     this._fieldValidations.set(path, {
       validators,
       validateOn: explicitTrigger,
       derivedTrigger
     });
+    for (const v of validators) {
+      if (v._dependsOnField) {
+        this._registerDependency(path, v._dependsOnField);
+      }
+    }
+    if (dependsOn) {
+      const deps = Array.isArray(dependsOn) ? dependsOn : [dependsOn];
+      for (const dep of deps) {
+        this._registerDependency(path, dep);
+      }
+    }
   }
   _deriveValidateOn(validators) {
     const hasAsync = validators.some((v) => v._isAsync);
@@ -325,17 +611,18 @@ class ValidationEngine {
   }
   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);
+    if (validation) {
+      const trigger = validation.validateOn ?? validation.derivedTrigger;
+      if (trigger === "change") {
+        const debounceMs = this._getDebounceMs(validation.validators);
+        if (debounceMs > 0) {
+          this._debounceValidation(path, debounceMs);
+        } else {
+          this._runFieldValidation(path);
+        }
+      }
     }
+    this._triggerDependents(path);
   }
   onFieldBlur(path) {
     const validation = this._fieldValidations.get(path);
@@ -382,16 +669,27 @@ class ValidationEngine {
     const generation = (this._fieldGenerations.get(path) ?? 0) + 1;
     this._fieldGenerations.set(path, generation);
     this._setFieldValidating(path, true);
-    const errors = [];
+    const syncErrors = [];
+    const asyncErrors = [];
     const value = this._store.getValue(path);
     const context = this._createContext(controller.signal);
     try {
-      for (const validator of validation.validators) {
+      const syncValidators = validation.validators.filter((v) => !v._isAsync);
+      const asyncValidators = validation.validators.filter((v) => v._isAsync);
+      for (const validator of syncValidators) {
         if (controller.signal.aborted)
           break;
         const result = await validator(value, context);
-        if (result) {
-          errors.push(result);
+        if (result)
+          syncErrors.push(result);
+      }
+      if (syncErrors.length === 0 && !controller.signal.aborted) {
+        for (const validator of asyncValidators) {
+          if (controller.signal.aborted)
+            break;
+          const result = await validator(value, context);
+          if (result)
+            asyncErrors.push(result);
         }
       }
     } finally {
@@ -400,9 +698,21 @@ class ValidationEngine {
         this._abortControllers.delete(path);
       }
     }
+    const allErrors = [...syncErrors, ...asyncErrors];
     if (!controller.signal.aborted && this._fieldGenerations.get(path) === generation) {
-      this._store.setErrors(path, errors);
-      return errors;
+      this._store.clearErrorsBySource(path, "sync");
+      this._store.clearErrorsBySource(path, "async");
+      if (syncErrors.length > 0) {
+        this._store.setErrorsWithSource(path, syncErrors, "sync");
+      }
+      if (asyncErrors.length > 0) {
+        this._store.setErrorsWithSource(path, asyncErrors, "async");
+      }
+      if (allErrors.length === 0) {
+        this._store.clearErrorsBySource(path, "sync");
+        this._store.clearErrorsBySource(path, "async");
+      }
+      return allErrors;
     }
     return [];
   }
@@ -426,9 +736,10 @@ class ValidationEngine {
     this._validateAllController = controller;
     const allErrors = {};
     let hasErrors = false;
+    let schemaResult = null;
     const schema = this._store.config.schema;
     if (schema) {
-      const schemaResult = await this._validateSchema(schema);
+      schemaResult = await this._validateSchema(schema);
       if (controller.signal.aborted)
         return { success: true };
       if (!schemaResult.success && schemaResult.errors) {
@@ -448,13 +759,24 @@ class ValidationEngine {
       const value = this._store.getValue(path);
       const context = this._createContext(controller.signal);
       const errors = [];
-      for (const validator of validation.validators) {
+      const syncValidators = validation.validators.filter((v) => !v._isAsync);
+      const asyncValidators = validation.validators.filter((v) => v._isAsync);
+      for (const validator of syncValidators) {
         if (controller.signal.aborted)
           break;
         const result = await validator(value, context);
         if (result)
           errors.push(result);
       }
+      if (errors.length === 0 && !controller.signal.aborted) {
+        for (const validator of asyncValidators) {
+          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];
@@ -470,15 +792,51 @@ class ValidationEngine {
       this._validateAllController = null;
     }
     this._store.clearErrors();
+    if (schema) {
+      const schemaErrors = schemaResult?.errors ?? {};
+      for (const [path, errors] of Object.entries(schemaErrors)) {
+        this._store.setErrorsWithSource(path, errors, "schema");
+      }
+    }
     for (const [path, errors] of Object.entries(allErrors)) {
-      this._store.setErrors(path, errors);
+      const schemaErrors = schemaResult?.errors ?? {};
+      if (schemaErrors[path]) {
+        const validation = this._fieldValidations.get(path);
+        const hasAsync = validation?.validators.some((v) => v._isAsync);
+        const source = hasAsync && errors.length > 0 ? "sync" : "sync";
+        const fieldOnlyErrors = errors.filter((e) => !schemaErrors[path]?.includes(e));
+        if (fieldOnlyErrors.length > 0) {
+          this._store.setErrorsWithSource(path, fieldOnlyErrors, source);
+        }
+      } else {
+        const validation = this._fieldValidations.get(path);
+        if (validation) {
+          const syncValidators = validation.validators.filter((v) => !v._isAsync);
+          const asyncValidators = validation.validators.filter((v) => v._isAsync);
+          if (syncValidators.length > 0 && errors.length > 0) {
+            this._store.setErrorsWithSource(path, errors, "sync");
+          } else if (asyncValidators.length > 0 && errors.length > 0) {
+            this._store.setErrorsWithSource(path, errors, "async");
+          } else {
+            this._store.setErrors(path, errors);
+          }
+        } else {
+          this._store.setErrors(path, errors);
+        }
+      }
     }
     return { success: !hasErrors, errors: hasErrors ? allErrors : undefined };
   }
   async _validateSchema(schema) {
+    let resolvedSchema;
+    if (isStandardSchema(schema)) {
+      resolvedSchema = standardSchemaAdapter(schema);
+    } else {
+      resolvedSchema = schema;
+    }
     const values = this._store._getCurrentValues();
-    if (schema.safeParse) {
-      const result = schema.safeParse(values);
+    if (resolvedSchema.safeParse) {
+      const result = resolvedSchema.safeParse(values);
       if (result.success) {
         return { success: true };
       }
@@ -494,7 +852,7 @@ class ValidationEngine {
       return { success: false, errors };
     }
     try {
-      schema.parse(values);
+      resolvedSchema.parse(values);
       return { success: true };
     } catch (e) {
       if (e?.issues) {
@@ -513,11 +871,48 @@ class ValidationEngine {
       };
     }
   }
+  getRegisteredPaths() {
+    return this._fieldValidations.keys();
+  }
+  _registerDependency(dependentField, sourceField) {
+    let set = this._dependents.get(sourceField);
+    if (!set) {
+      set = new Set;
+      this._dependents.set(sourceField, set);
+    }
+    set.add(dependentField);
+  }
+  _triggerDependents(sourcePath) {
+    const dependents = this._dependents.get(sourcePath);
+    if (!dependents)
+      return;
+    for (const dep of dependents) {
+      if (this._validatingDependents.has(dep))
+        continue;
+      const validation = this._fieldValidations.get(dep);
+      if (!validation)
+        continue;
+      if (!this._store.getTouched(dep))
+        continue;
+      this._validatingDependents.add(dep);
+      this._runFieldValidation(dep);
+      Promise.resolve().then(() => {
+        this._validatingDependents.delete(dep);
+      });
+    }
+  }
+  getDependents(sourcePath) {
+    return this._dependents.get(sourcePath);
+  }
   unregisterField(path) {
     this._cancelFieldValidation(path);
     this._fieldValidations.delete(path);
     this._validatingSignals.delete(path);
     this._fieldGenerations.delete(path);
+    this._dependents.delete(path);
+    for (const [, set] of this._dependents) {
+      set.delete(path);
+    }
   }
   dispose() {
     for (const timer of this._debounceTimers.values()) {
@@ -531,6 +926,8 @@ class ValidationEngine {
     this._validatingFields.clear();
     this._validatingSignals.clear();
     this._fieldGenerations.clear();
+    this._dependents.clear();
+    this._validatingDependents.clear();
     if (this._validateAllController) {
       this._validateAllController.abort();
       this._validateAllController = null;
@@ -579,11 +976,203 @@ class ValidationEngine {
   }
 }
 
+// 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/store.ts
 class FormStore {
   config;
   _signals = new Map;
   _errorSignals = new Map;
+  _errorMapSignals = new Map;
   _formErrors;
   _baseline;
   _touchedSet = new Set;
@@ -815,6 +1404,11 @@ class FormStore {
   }
   setErrors(path, errors) {
     this.getErrors(path).set(errors);
+    const mapSig = this._errorMapSignals.get(path);
+    if (mapSig) {
+      const current = mapSig.get();
+      mapSig.set({ ...current, manual: errors });
+    }
     this._updateIsValid();
     this._notifySubscribers();
   }
@@ -823,10 +1417,16 @@ class FormStore {
       const sig = this._errorSignals.get(path);
       if (sig)
         sig.set([]);
+      const mapSig = this._errorMapSignals.get(path);
+      if (mapSig)
+        mapSig.set(this._emptyErrorMap());
     } else {
       for (const sig of this._errorSignals.values()) {
         sig.set([]);
       }
+      for (const sig of this._errorMapSignals.values()) {
+        sig.set(this._emptyErrorMap());
+      }
       this._formErrors.set([]);
     }
     this._updateIsValid();
@@ -837,6 +1437,44 @@ class FormStore {
     this._updateIsValid();
     this._notifySubscribers();
   }
+  _emptyErrorMap() {
+    return { sync: [], async: [], schema: [], server: [], manual: [] };
+  }
+  getErrorMap(path) {
+    let sig = this._errorMapSignals.get(path);
+    if (!sig) {
+      sig = signal2(this._emptyErrorMap());
+      this._errorMapSignals.set(path, sig);
+    }
+    return sig;
+  }
+  setErrorsWithSource(path, errors, source) {
+    const mapSig = this.getErrorMap(path);
+    const current = mapSig.get();
+    const updated = { ...current, [source]: errors };
+    mapSig.set(updated);
+    this._rebuildFlatErrors(path, updated);
+  }
+  clearErrorsBySource(path, source) {
+    const mapSig = this._errorMapSignals.get(path);
+    if (!mapSig)
+      return;
+    const current = mapSig.get();
+    if (current[source].length === 0)
+      return;
+    const updated = { ...current, [source]: [] };
+    mapSig.set(updated);
+    this._rebuildFlatErrors(path, updated);
+  }
+  _rebuildFlatErrors(path, errorMap) {
+    const flat = [];
+    for (const source of ["sync", "async", "schema", "server", "manual"]) {
+      flat.push(...errorMap[source]);
+    }
+    this.getErrors(path).set(flat);
+    this._updateIsValid();
+    this._notifySubscribers();
+  }
   _updateIsValid() {
     let valid = this._formErrors.get().length === 0;
     if (valid) {
@@ -870,7 +1508,7 @@ class FormStore {
     if (options) {
       this._fieldOptions.set(path, options);
       if (options.validate) {
-        this._validationEngine.registerFieldValidators(path, Array.isArray(options.validate) ? options.validate : [options.validate], options.validateOn);
+        this._validationEngine.registerFieldValidators(path, Array.isArray(options.validate) ? options.validate : [options.validate], options.validateOn, options.dependsOn);
       }
     }
     const value = this.getValue(path);
@@ -936,7 +1574,10 @@ class FormStore {
     if (e)
       e.preventDefault?.();
     if (!this.config.onSubmit) {
-      await this._validationEngine.validateAll();
+      const result = await this._validationEngine.validateAll();
+      if (!result.success && this.config.focusOnError !== false) {
+        focusFirstError(this);
+      }
       return;
     }
     await this.submitWith(this.config.onSubmit);
@@ -970,6 +1611,9 @@ class FormStore {
           this.isSubmitting.set(false);
           this.submitState.set("error");
         });
+        if (this.config.focusOnError !== false) {
+          focusFirstError(this);
+        }
         return;
       }
       const values = this._getCurrentValues();
@@ -1003,6 +1647,32 @@ class FormStore {
     const result = await this._validationEngine.validateAll();
     return result.success;
   }
+  resetField(path) {
+    batch(() => {
+      const baseline = getPath(this._baseline, path);
+      this.setValue(path, baseline);
+      this.clearErrors(path);
+      this.setTouched(path, false);
+      this._dirtySet.delete(path);
+      this.isDirty.set(this._dirtySet.size > 0);
+    });
+  }
+  async trigger(path) {
+    if (path) {
+      this.setTouched(path, true);
+      const errors = await this._validationEngine.validateField(path);
+      return errors.length === 0;
+    }
+    for (const p of this._fieldOptions.keys()) {
+      this._touchedSet.add(p);
+    }
+    for (const p of this._validationEngine.getRegisteredPaths()) {
+      this._touchedSet.add(p);
+    }
+    this._notifySubscribers();
+    const result = await this._validationEngine.validateAll();
+    return result.success;
+  }
   reset() {
     this.resetTo(deepClone(this.config.defaultValues));
   }
@@ -1112,6 +1782,7 @@ class FormStore {
     this._watchers.clear();
     this._fieldRefs.clear();
     this._fieldOptions.clear();
+    this._errorMapSignals.clear();
     if (this._submitAbort) {
       this._submitAbort.abort();
       this._submitAbort = null;
@@ -1199,38 +1870,41 @@ function useForm(config) {
   return storeRef.current;
 }
 function useField(form, name, opts) {
+  const f = form;
   const optsRef = useRef(opts);
   const registered = useRef(false);
   if (!registered.current || optsRef.current !== opts) {
     optsRef.current = opts;
     if (opts) {
-      form.register(name, opts);
+      f.register(name, opts);
     }
     registered.current = true;
   }
   useEffect(() => {
     return () => {
-      form.unregister(name);
+      f.unregister(name);
     };
-  }, [form, name]);
-  const valueSig = form.getSignal(name);
+  }, [f, name]);
+  const valueSig = f.getSignal(name);
   const value = useSignal(valueSig);
-  const errorsSig = form.getErrors(name);
+  const errorsSig = f.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 touched = useSyncExternalStore(useCallback((cb) => f.subscribe(cb), [f]), () => f.getTouched(name), () => f.getTouched(name));
+  const dirty = useSyncExternalStore(useCallback((cb) => f.subscribe(cb), [f]), () => f.getDirty(name), () => f.getDirty(name));
+  const validatingSig = f.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 errorMapSig = f.getErrorMap(name);
+  const errorMap = useSignal(errorMapSig);
+  const setValue = useCallback((v) => f.setValue(name, v), [f, name]);
+  const setError = useCallback((errs) => f.setErrors(name, errs), [f, name]);
+  const clearErrors = useCallback(() => f.clearErrors(name), [f, name]);
+  const setTouched = useCallback((t) => f.setTouched(name, t), [f, name]);
   const reset = useCallback(() => {
     const baseline = getPath(form.getBaseline(), name);
-    form.setValue(name, baseline);
-    form.clearErrors(name);
-    form.setTouched(name, false);
-  }, [form, name]);
+    f.setValue(name, baseline);
+    f.clearErrors(name);
+    f.setTouched(name, false);
+  }, [f, form, name]);
   const onChange = useCallback((e) => {
     let newValue;
     if (opts?.parse) {
@@ -1244,12 +1918,12 @@ function useField(form, name, opts) {
     if (opts?.transform) {
       newValue = opts.transform(newValue);
     }
-    form.setValue(name, newValue);
-  }, [form, name, opts]);
+    f.setValue(name, newValue);
+  }, [f, name, opts]);
   const onBlur = useCallback(() => {
-    form.setTouched(name);
-    form.triggerBlurValidation(name);
-  }, [form, name]);
+    f.setTouched(name);
+    f.triggerBlurValidation(name);
+  }, [f, name]);
   const refCallback = useCallback((el) => {
     if (form.setFieldRef) {
       form.setFieldRef(name, el);
@@ -1273,6 +1947,7 @@ function useField(form, name, opts) {
     touched,
     dirty,
     validating,
+    errorMap,
     setValue,
     setError,
     clearErrors,
@@ -1281,14 +1956,14 @@ function useField(form, name, opts) {
   };
 }
 function useFieldArray(form, name) {
-  const idCounter = useRef(0);
+  const idCounter2 = 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++}`);
+      idsRef.current.push(`${name}-${idCounter2.current++}`);
     }
   } else if (idsRef.current.length > items.length) {
     idsRef.current.length = items.length;
@@ -1300,12 +1975,12 @@ function useFieldArray(form, name) {
   })), [items, name]);
   const append = useCallback((value) => {
     const current = form.getValue(name) ?? [];
-    idsRef.current = [...idsRef.current, `${name}-${idCounter.current++}`];
+    idsRef.current = [...idsRef.current, `${name}-${idCounter2.current++}`];
     form.setValue(name, [...current, value]);
   }, [form, name]);
   const prepend = useCallback((value) => {
     const current = form.getValue(name) ?? [];
-    idsRef.current = [`${name}-${idCounter.current++}`, ...idsRef.current];
+    idsRef.current = [`${name}-${idCounter2.current++}`, ...idsRef.current];
     form.setValue(name, [value, ...current]);
   }, [form, name]);
   const insert = useCallback((index, value) => {
@@ -1313,7 +1988,7 @@ function useFieldArray(form, name) {
     const next = [...current];
     next.splice(index, 0, value);
     const ids = [...idsRef.current];
-    ids.splice(index, 0, `${name}-${idCounter.current++}`);
+    ids.splice(index, 0, `${name}-${idCounter2.current++}`);
     idsRef.current = ids;
     form.setValue(name, next);
   }, [form, name]);
@@ -1353,7 +2028,7 @@ function useFieldArray(form, name) {
     form.setValue(name, next);
   }, [form, name]);
   const replaceAll = useCallback((values) => {
-    idsRef.current = values.map(() => `${name}-${idCounter.current++}`);
+    idsRef.current = values.map(() => `${name}-${idCounter2.current++}`);
     form.setValue(name, values);
   }, [form, name]);
   const clone = useCallback((index) => {
@@ -1362,7 +2037,7 @@ function useFieldArray(form, name) {
     const cloned = deepClone(current[index]);
     next.splice(index + 1, 0, cloned);
     const ids = [...idsRef.current];
-    ids.splice(index + 1, 0, `${name}-${idCounter.current++}`);
+    ids.splice(index + 1, 0, `${name}-${idCounter2.current++}`);
     idsRef.current = ids;
     form.setValue(name, next);
   }, [form, name]);
@@ -1375,225 +2050,53 @@ function useFieldArray(form, name) {
     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");
+    replaceAll,
+    clone
+  };
 }
-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 useWatch(form, pathOrPaths) {
+  const f = form;
+  if (typeof pathOrPaths === "string") {
+    const sig = f.getSignal(pathOrPaths);
+    return useSignal(sig);
+  }
+  const prevRef = useRef([]);
+  const subscribe = useCallback((cb) => {
+    const unsubs = pathOrPaths.map((p) => f.getSignal(p).subscribe(cb));
+    return () => unsubs.forEach((u) => u());
+  }, [f, ...pathOrPaths]);
+  const getSnapshot = useCallback(() => {
+    const next = pathOrPaths.map((p) => f.getValue(p));
+    if (next.length === prevRef.current.length && next.every((v, i) => v === prevRef.current[i])) {
+      return prevRef.current;
+    }
+    prevRef.current = next;
+    return next;
+  }, [f, ...pathOrPaths]);
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }
-function prefersReducedMotion() {
-  if (typeof window === "undefined")
-    return false;
-  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+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 };
 }
-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/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";
 function inferInputType(name, explicitType) {
   if (explicitType)
     return explicitType;
@@ -1855,6 +2358,7 @@ function matches(otherField, msg) {
     return value === other ? undefined : msg ?? `Must match ${otherField}`;
   };
   validator._crossField = true;
+  validator._dependsOnField = otherField;
   return validator;
 }
 function oneOf(values, msg) {
@@ -1954,219 +2458,6 @@ var v = {
   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";
@@ -2308,7 +2599,7 @@ function ActionForm(props) {
         if (result.errors) {
           for (const [path, errors] of Object.entries(result.errors)) {
             if (path) {
-              form.setErrors(path, errors);
+              form.setErrorsWithSource(path, errors, "server");
             } else {
               form.setFormErrors(errors);
             }
@@ -2868,6 +3159,7 @@ export {
   v,
   useWizardContext,
   useWizard,
+  useWatch,
   useFormStatus,
   useFormContext,
   useFormAction,
@@ -2876,6 +3168,7 @@ export {
   useField,
   url,
   trapFocus,
+  standardSchemaAdapter,
   setPath,
   required,
   prefersReducedMotion,
@@ -2893,6 +3186,7 @@ export {
   maxLength,
   max,
   matches,
+  isStandardSchema,
   isScreenReaderActive,
   isEreoSchema,
   integer,