attaform 0.17.1 → 0.18.0

package/dist/shared/{attaform.BV40t5y2.cjs → attaform.Dlk1jMuv.cjs}

@@ -1,9 +1,8 @@
 'use strict';
 
-const useFormContext = require('./attaform.Cer8JO_P.cjs');
-const plugin = require('./attaform.Dee2rU1P.cjs');
+const injectWizard = require('./attaform.II89Pcf4.cjs');
+const paths = require('./attaform.BqK_L4gK.cjs');
 const fieldMetaStore = require('./attaform.C8CyvYa_.cjs');
-const paths = require('./attaform.BBM2muQ9.cjs');
 const zod = require('zod');
 
 const fieldMeta = fieldMetaStore.fieldMetaStore;
@@ -28,7 +27,7 @@ function zodIssuesToValidationErrors(issues, formKey) {
       code = `zod:${issue.code}`;
     } else {
       code = "zod:unknown";
-      if (plugin.__DEV__ && !warnedZodCodeMissing) {
+      if (paths.__DEV__ && !warnedZodCodeMissing) {
         warnedZodCodeMissing = true;
         console.warn(
           "[attaform] zod-v4 adapter received an issue with no string `code`; stamping `'zod:unknown'`. This usually means a custom Zod plugin emitted an issue without the standard code field."
@@ -47,7 +46,7 @@ function zodIssuesToValidationErrors(issues, formKey) {
     };
   });
 }
-class UnsupportedSchemaError extends plugin.AttaformError {
+class UnsupportedSchemaError extends paths.AttaformError {
 }
 
 function readDef(schema) {
@@ -126,6 +125,8 @@ function kindOf(schema) {
     case "template_literal":
     case "templateLiteral":
       return "template-literal";
+    case "file":
+      return "file";
     default:
       return "unknown";
   }
@@ -180,14 +181,13 @@ function unwrapPipeIn(schema) {
   const def = readDef(schema);
   return def?.in;
 }
+function isCoercePrimitive(schema) {
+  return readDef(schema)?.coerce === true;
+}
 function unwrapPipeOut(schema) {
   const def = readDef(schema);
   return def?.out;
 }
-function readTransformFn(schema) {
-  const def = readDef(schema);
-  return typeof def?.transform === "function" ? def.transform : void 0;
-}
 function unwrapLazy(schema) {
   const def = readDef(schema);
   const getter = def?.getter;
@@ -312,6 +312,70 @@ function containsAsyncRefine(schema, seen) {
   }
   return false;
 }
+function containsAsyncTransform(schema, seen) {
+  const visited = seen ?? /* @__PURE__ */ new WeakSet();
+  const candidate = schema;
+  if (typeof candidate !== "object" || candidate === null) return false;
+  if (visited.has(candidate)) return false;
+  visited.add(candidate);
+  const def = readDef(schema);
+  if (def === void 0) return false;
+  if (typeof def.transform === "function" && def.transform.constructor.name === "AsyncFunction") {
+    return true;
+  }
+  if (def.innerType !== void 0 && containsAsyncTransform(def.innerType, visited)) {
+    return true;
+  }
+  if (def.element !== void 0 && containsAsyncTransform(def.element, visited)) {
+    return true;
+  }
+  if (def.in !== void 0 && containsAsyncTransform(def.in, visited)) {
+    return true;
+  }
+  if (def.out !== void 0 && containsAsyncTransform(def.out, visited)) {
+    return true;
+  }
+  if (def.left !== void 0 && containsAsyncTransform(def.left, visited)) {
+    return true;
+  }
+  if (def.right !== void 0 && containsAsyncTransform(def.right, visited)) {
+    return true;
+  }
+  if (def.keyType !== void 0 && containsAsyncTransform(def.keyType, visited)) {
+    return true;
+  }
+  if (def.valueType !== void 0 && containsAsyncTransform(def.valueType, visited)) {
+    return true;
+  }
+  if (def.shape !== void 0) {
+    for (const sub of Object.values(def.shape)) {
+      if (containsAsyncTransform(sub, visited)) return true;
+    }
+  }
+  if (def.entries !== void 0) {
+    for (const sub of Object.values(def.entries)) {
+      if (containsAsyncTransform(sub, visited)) return true;
+    }
+  }
+  if (def.options !== void 0) {
+    for (const sub of def.options) {
+      if (containsAsyncTransform(sub, visited)) return true;
+    }
+  }
+  if (def.items !== void 0) {
+    for (const sub of def.items) {
+      if (containsAsyncTransform(sub, visited)) return true;
+    }
+  }
+  if (typeof def.getter === "function") {
+    try {
+      const inner = def.getter();
+      if (containsAsyncTransform(inner, visited)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
 function isAsyncCheck(check) {
   if (typeof check !== "object" || check === null) return false;
   const c = check;
@@ -416,6 +480,7 @@ function assertSupportedKinds(schema, path = [], lazyGetters = []) {
     case "custom":
     case "template-literal":
     case "transform":
+    case "file":
       return;
     default: {
       const _exhaustive = kind;
@@ -571,6 +636,7 @@ function computeFingerprint(schema, cache, inProgress) {
     case "custom":
     case "template-literal":
     case "transform":
+    case "file":
       return `${kind}:*`;
     default: {
       const _ = kind;
@@ -650,30 +716,45 @@ const PERMISSIVE = /* @__PURE__ */ new Set([
   "symbol",
   "function",
   "map",
-  "set"
+  "set",
+  "file"
 ]);
+const KIND_STRING = /* @__PURE__ */ new Set(["string"]);
+const KIND_NUMBER = /* @__PURE__ */ new Set(["number"]);
+const KIND_BOOLEAN = /* @__PURE__ */ new Set(["boolean"]);
+const KIND_BIGINT = /* @__PURE__ */ new Set(["bigint"]);
+const KIND_DATE = /* @__PURE__ */ new Set(["date"]);
+const KIND_NULL = /* @__PURE__ */ new Set(["null"]);
+const KIND_UNDEFINED = /* @__PURE__ */ new Set(["undefined"]);
+const KIND_OBJECT = /* @__PURE__ */ new Set(["object"]);
+const KIND_ARRAY = /* @__PURE__ */ new Set(["array"]);
+const KIND_SET = /* @__PURE__ */ new Set(["set"]);
+const KIND_FILE = /* @__PURE__ */ new Set(["file", "null"]);
+const EMPTY_KINDS = /* @__PURE__ */ new Set();
 function slimPrimitivesOf(schema, maxRecursionDepth) {
-  return walk(schema, 0, maxRecursionDepth);
+  return new Set(walk(schema, 0, maxRecursionDepth));
 }
 function walk(schema, lazyDepth, maxDepth) {
   const kind = kindOf(schema);
   switch (kind) {
     case "string":
-      return /* @__PURE__ */ new Set(["string"]);
+      return KIND_STRING;
     case "number":
     case "nan":
-      return /* @__PURE__ */ new Set(["number"]);
+      return KIND_NUMBER;
     case "boolean":
-      return /* @__PURE__ */ new Set(["boolean"]);
+      return KIND_BOOLEAN;
     case "bigint":
-      return /* @__PURE__ */ new Set(["bigint"]);
+      return KIND_BIGINT;
     case "date":
-      return /* @__PURE__ */ new Set(["date"]);
+      return KIND_DATE;
+    case "file":
+      return KIND_FILE;
     case "null":
-      return /* @__PURE__ */ new Set(["null"]);
+      return KIND_NULL;
     case "undefined":
     case "void":
-      return /* @__PURE__ */ new Set(["undefined"]);
+      return KIND_UNDEFINED;
     case "enum": {
       const values = getEnumValues(schema);
       const out = /* @__PURE__ */ new Set();
@@ -681,48 +762,52 @@ function walk(schema, lazyDepth, maxDepth) {
         if (typeof v === "string") out.add("string");
         else if (typeof v === "number") out.add("number");
       }
-      return out.size === 0 ? /* @__PURE__ */ new Set(["string"]) : out;
+      return out.size === 0 ? KIND_STRING : out;
     }
     case "literal": {
       const values = getLiteralValues(schema);
       const out = /* @__PURE__ */ new Set();
       for (const v of values) out.add(slimKindOfRaw(v));
-      return out.size === 0 ? new Set(PERMISSIVE) : out;
+      return out.size === 0 ? PERMISSIVE : out;
     }
     case "object":
     case "record":
-      return /* @__PURE__ */ new Set(["object"]);
+      return KIND_OBJECT;
     case "array":
     case "tuple":
-      return /* @__PURE__ */ new Set(["array"]);
+      return KIND_ARRAY;
     case "set":
-      return /* @__PURE__ */ new Set(["set"]);
+      return KIND_SET;
     case "optional": {
       const inner = unwrapInner(schema);
-      const innerSet = inner === void 0 ? /* @__PURE__ */ new Set() : walk(inner, lazyDepth, maxDepth);
-      innerSet.add("undefined");
-      return innerSet;
+      const innerSet = inner === void 0 ? EMPTY_KINDS : walk(inner, lazyDepth, maxDepth);
+      const out = new Set(innerSet);
+      out.add("undefined");
+      return out;
     }
     case "nullable": {
       const inner = unwrapInner(schema);
-      const innerSet = inner === void 0 ? /* @__PURE__ */ new Set() : walk(inner, lazyDepth, maxDepth);
-      innerSet.add("null");
-      return innerSet;
+      const innerSet = inner === void 0 ? EMPTY_KINDS : walk(inner, lazyDepth, maxDepth);
+      const out = new Set(innerSet);
+      out.add("null");
+      return out;
     }
     case "default":
     case "readonly":
     case "catch": {
       const inner = unwrapInner(schema);
-      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, lazyDepth, maxDepth);
+      return inner === void 0 ? PERMISSIVE : walk(inner, lazyDepth, maxDepth);
     }
     case "pipe": {
-      const inner = unwrapPipe(schema);
-      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, lazyDepth, maxDepth);
+      const pipeIn = unwrapPipeIn(schema);
+      const pipeOut = unwrapPipeOut(schema);
+      const inner = pipeIn !== void 0 && kindOf(pipeIn) === "transform" ? pipeOut : pipeIn ?? pipeOut;
+      return inner === void 0 ? PERMISSIVE : walk(inner, lazyDepth, maxDepth);
     }
     case "lazy": {
-      if (lazyDepth >= maxDepth) return new Set(PERMISSIVE);
+      if (lazyDepth >= maxDepth) return PERMISSIVE;
       const inner = unwrapLazy(schema);
-      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, lazyDepth + 1, maxDepth);
+      return inner === void 0 ? PERMISSIVE : walk(inner, lazyDepth + 1, maxDepth);
     }
     case "union":
     case "discriminated-union": {
@@ -731,22 +816,22 @@ function walk(schema, lazyDepth, maxDepth) {
       for (const opt of options) {
         for (const k of walk(opt, lazyDepth, maxDepth)) out.add(k);
       }
-      return out.size === 0 ? new Set(PERMISSIVE) : out;
+      return out.size === 0 ? PERMISSIVE : out;
     }
     case "intersection": {
       const left = getIntersectionLeft(schema);
       const right = getIntersectionRight(schema);
-      const leftSet = left === void 0 ? new Set(PERMISSIVE) : walk(left, lazyDepth, maxDepth);
-      const rightSet = right === void 0 ? new Set(PERMISSIVE) : walk(right, lazyDepth, maxDepth);
+      const leftSet = left === void 0 ? PERMISSIVE : walk(left, lazyDepth, maxDepth);
+      const rightSet = right === void 0 ? PERMISSIVE : walk(right, lazyDepth, maxDepth);
       const out = /* @__PURE__ */ new Set();
       for (const k of leftSet) if (rightSet.has(k)) out.add(k);
       return out;
     }
     case "never":
-      return /* @__PURE__ */ new Set();
+      return EMPTY_KINDS;
     case "any":
     case "unknown":
-      return new Set(PERMISSIVE);
+      return PERMISSIVE;
     // Kinds we don't understand at the slim level: be permissive to
     // avoid false-rejecting legitimate writes against schema shapes
     // we haven't characterised.
@@ -754,9 +839,9 @@ function walk(schema, lazyDepth, maxDepth) {
     case "custom":
     case "template-literal":
     case "transform":
-      return new Set(PERMISSIVE);
+      return PERMISSIVE;
     default:
-      return new Set(PERMISSIVE);
+      return PERMISSIVE;
   }
 }
 function slimKindOfRaw(value) {
@@ -875,6 +960,7 @@ function walkSegments(schema, segments, maxDepth, lazyDepth) {
     case "custom":
     case "template-literal":
     case "transform":
+    case "file":
       return [];
     default: {
       const _exhaustive = kind;
@@ -987,6 +1073,7 @@ function stripRefinements(schema) {
     case "custom":
     case "template-literal":
     case "transform":
+    case "file":
       return schema;
     default: {
       const _exhaustive = kind;
@@ -1111,6 +1198,7 @@ function stripAsyncChecks(schema) {
       case "custom":
       case "template-literal":
       case "transform":
+      case "file":
         return s;
       default: {
         const _exhaustive = kind;
@@ -1256,6 +1344,7 @@ function walkSlim(schema, stripConfig, maxDepth, lazyDepth) {
       return slimmedInner.catch(getCatchDefault(schema));
     }
     case "transform":
+    case "file":
       return schema;
     default: {
       const _exhaustive = kind;
@@ -1264,10 +1353,25 @@ function walkSlim(schema, stripConfig, maxDepth, lazyDepth) {
   }
 }
 
+function hasDeclaredDefaultInChain(schema) {
+  let current = schema;
+  for (let i = 0; i < 32; i++) {
+    if (current === void 0) return false;
+    const k = kindOf(current);
+    if (k === "default") return true;
+    if (k === "optional" || k === "nullable" || k === "readonly" || k === "catch") {
+      current = unwrapInner(current);
+      continue;
+    }
+    return false;
+  }
+  return false;
+}
 function deriveDefault(schema, useDefault, maxRecursionDepth) {
   return defaultForKind(kindOf(schema), schema, useDefault, maxRecursionDepth, 0);
 }
 function defaultForKind(kind, schema, useDefault, maxDepth, lazyDepth) {
+  if (isCoercePrimitive(schema)) return void 0;
   switch (kind) {
     case "object": {
       const shape = getObjectShape(schema);
@@ -1291,8 +1395,15 @@ function defaultForKind(kind, schema, useDefault, maxDepth, lazyDepth) {
       return inner === void 0 ? void 0 : defaultForKind(kindOf(inner), inner, useDefault, maxDepth, lazyDepth);
     }
     case "pipe": {
-      const out = unwrapPipeOut(schema);
       const inn = unwrapPipeIn(schema);
+      if (inn !== void 0 && kindOf(inn) === "transform") {
+        const out2 = unwrapPipeOut(schema);
+        if (out2 !== void 0 && hasDeclaredDefaultInChain(out2)) {
+          return defaultForKind(kindOf(out2), out2, useDefault, maxDepth, lazyDepth);
+        }
+        return void 0;
+      }
+      const out = unwrapPipeOut(schema);
       const real = inn !== void 0 && kindOf(inn) !== "transform" ? inn : out !== void 0 && kindOf(out) !== "transform" ? out : inn ?? out;
       return real === void 0 ? void 0 : defaultForKind(kindOf(real), real, useDefault, maxDepth, lazyDepth);
     }
@@ -1343,7 +1454,12 @@ function defaultForKind(kind, schema, useDefault, maxDepth, lazyDepth) {
       return NaN;
     case "lazy": {
       if (lazyDepth >= maxDepth) return void 0;
-      const inner = unwrapLazy(schema);
+      let inner;
+      try {
+        inner = unwrapLazy(schema);
+      } catch {
+        return void 0;
+      }
       return inner === void 0 ? void 0 : defaultForKind(kindOf(inner), inner, useDefault, maxDepth, lazyDepth + 1);
     }
     case "intersection": {
@@ -1367,6 +1483,8 @@ function defaultForKind(kind, schema, useDefault, maxDepth, lazyDepth) {
     case "template-literal":
     case "transform":
       return void 0;
+    case "file":
+      return null;
     default: {
       const _exhaustive = kind;
       throw new Error(`deriveDefault: unhandled ZodKind '${_exhaustive}'`);
@@ -1375,15 +1493,15 @@ function defaultForKind(kind, schema, useDefault, maxDepth, lazyDepth) {
 }
 function mergeDeep(base, override) {
   if (override === void 0) return base;
-  if (!useFormContext.isPlainRecord(override)) return override;
-  if (!useFormContext.isPlainRecord(base)) return override;
+  if (!injectWizard.isPlainRecord(override)) return override;
+  if (!injectWizard.isPlainRecord(base)) return override;
   const result = { ...base };
   for (const key of Object.keys(override)) {
     const oVal = override[key];
     const bVal = base[key];
-    if (useFormContext.isPlainRecord(oVal) && useFormContext.isPlainRecord(bVal)) {
+    if (injectWizard.isPlainRecord(oVal) && injectWizard.isPlainRecord(bVal)) {
       result[key] = mergeDeep(bVal, oVal);
-    } else if (oVal !== void 0) {
+    } else {
       result[key] = oVal;
     }
   }
@@ -1409,18 +1527,26 @@ function getDefaultValuesFromZodSchema(opts) {
   let fixedData = merged;
   for (const issue of firstParse.error.issues) {
     const pathSegments = issue.path.map((seg) => typeof seg === "number" ? seg : String(seg));
+    const originalCandidate = getNestedZodSchemasAtPath(schema, pathSegments, maxRecursionDepth)[0];
+    if (originalCandidate !== void 0) {
+      if (isCoercePrimitive(originalCandidate)) continue;
+      if (kindOf(originalCandidate) === "pipe") {
+        const pipeIn = unwrapPipeIn(originalCandidate);
+        if (pipeIn !== void 0 && kindOf(pipeIn) === "transform") continue;
+      }
+    }
     const candidates = getNestedZodSchemasAtPath(slimSchema, pathSegments, maxRecursionDepth);
     if (candidates.length === 0) continue;
     const candidate = candidates[0];
     if (candidate === void 0) continue;
-    const valueAtPath = useFormContext.getAtPath(merged, pathSegments);
+    const valueAtPath = injectWizard.getAtPath(merged, pathSegments);
     const slimKinds = slimPrimitivesOf(candidate, maxRecursionDepth);
-    if (slimKinds.size > 0 && slimKinds.has(useFormContext.slimKindOf(valueAtPath))) {
+    if (slimKinds.size > 0 && slimKinds.has(injectWizard.slimKindOf(valueAtPath))) {
       continue;
     }
     const fixValue = defaultFromIssue(issue, candidate, useDefaultSchemaValues, maxRecursionDepth);
     if (fixValue === SKIP) continue;
-    fixedData = pathSegments.length === 0 ? fixValue : useFormContext.setAtPath(fixedData, pathSegments, fixValue);
+    fixedData = pathSegments.length === 0 ? fixValue : injectWizard.setAtPath(fixedData, pathSegments, fixValue);
   }
   const secondParse = slimSchema.safeParse(fixedData);
   if (secondParse.success) {
@@ -1537,11 +1663,12 @@ function zodV4Adapter(rootSchema) {
   return (formKey, options) => {
     const maxRecursionDepth = options.maxRecursionDepth;
     const leafCache = /* @__PURE__ */ new Map();
+    const preprocessOrCoerceCache = /* @__PURE__ */ new Map();
     let asyncValidationFlag = null;
     return {
       fingerprint: () => fingerprintZodSchema(rootSchema),
       needsAsyncValidation() {
-        asyncValidationFlag ?? (asyncValidationFlag = containsAsyncRefine(rootSchema));
+        asyncValidationFlag ?? (asyncValidationFlag = containsAsyncRefine(rootSchema) || containsAsyncTransform(rootSchema));
         return asyncValidationFlag;
       },
       getDefaultValues(config) {
@@ -1552,8 +1679,12 @@ function zodV4Adapter(rootSchema) {
           maxRecursionDepth
         });
         if (config.strict !== false) {
+          if (containsAsyncTransform(rootSchema)) {
+            return { data, errors: void 0, success: true, formKey };
+          }
+          const parseTarget = containsAsyncRefine(rootSchema) ? stripAsyncChecks(rootSchema) : rootSchema;
           try {
-            const strictResult = rootSchema.safeParse(
+            const strictResult = parseTarget.safeParse(
               data
             );
             if (strictResult.success) {
@@ -1566,56 +1697,11 @@ function zodV4Adapter(rootSchema) {
               formKey
             };
           } catch {
-            try {
-              const syncOnly = stripAsyncChecks(rootSchema);
-              const syncResult = syncOnly.safeParse(data);
-              if (syncResult.success) {
-                return { data, errors: void 0, success: true, formKey };
-              }
-              return {
-                data,
-                errors: zodIssuesToValidationErrors(syncResult.error.issues, formKey),
-                success: false,
-                formKey
-              };
-            } catch {
-              return { data, errors: void 0, success: true, formKey };
-            }
+            return { data, errors: void 0, success: true, formKey };
           }
         }
         return { data, errors: void 0, success: true, formKey };
       },
-      normalizeWriteValueAtPath(value, path) {
-        const candidates = path.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
-        const [first] = candidates;
-        if (first === void 0) return value;
-        let current = first;
-        let result = value;
-        for (let i = 0; i < 64; i++) {
-          if (kindOf(current) !== "pipe") break;
-          const pipeIn = unwrapPipeIn(current);
-          if (pipeIn === void 0 || kindOf(pipeIn) !== "transform") break;
-          const fn = readTransformFn(pipeIn);
-          if (typeof fn !== "function") break;
-          let next;
-          try {
-            next = fn(result);
-          } catch (cause) {
-            throw new Error(
-              `[attaform] input normalization at path "${path.join(".")}" threw \u2014 write rejected.`,
-              { cause }
-            );
-          }
-          if (next instanceof Promise) {
-            return value;
-          }
-          result = next;
-          const out = unwrapPipeOut(current);
-          if (out === void 0) break;
-          current = out;
-        }
-        return result;
-      },
       getDefaultAtPath(path) {
         if (path.length === 0) return deriveDefault(rootSchema, true, maxRecursionDepth);
         const [first] = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
@@ -1685,6 +1771,30 @@ function zodV4Adapter(rootSchema) {
         leafCache.set(cacheKey, isLeaf);
         return isLeaf;
       },
+      isPreprocessOrCoerceLeaf(path) {
+        const cacheKey = paths.canonicalizePath(path).key;
+        const cached = preprocessOrCoerceCache.get(cacheKey);
+        if (cached !== void 0) return cached;
+        let hit = false;
+        for (let i = 0; i <= path.length && !hit; i++) {
+          const prefix = path.slice(0, i);
+          const candidates = prefix.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, prefix, maxRecursionDepth);
+          for (const candidate of candidates) {
+            if (isCoercePrimitive(candidate)) {
+              hit = true;
+              break;
+            }
+            if (kindOf(candidate) !== "pipe") continue;
+            const pipeIn = unwrapPipeIn(candidate);
+            if (pipeIn !== void 0 && kindOf(pipeIn) === "transform") {
+              hit = true;
+              break;
+            }
+          }
+        }
+        preprocessOrCoerceCache.set(cacheKey, hit);
+        return hit;
+      },
       isRequiredAtPath(path) {
         if (path.length === 0) return true;
         const resolved = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
@@ -1771,9 +1881,14 @@ function zodV4Adapter(rootSchema) {
         }
         async function runAsync() {
           if (path === void 0) {
-            const result = await rootSchema.safeParseAsync(
-              data
-            );
+            let result;
+            try {
+              result = await rootSchema.safeParseAsync(
+                data
+              );
+            } catch (err) {
+              return validatorThrewResponse(err, []);
+            }
             return result.success ? { data: result.data, errors: void 0, success: true, formKey } : {
               data: void 0,
               errors: zodIssuesToValidationErrors(result.error.issues, formKey),
@@ -1785,7 +1900,12 @@ function zodV4Adapter(rootSchema) {
           if (resolved.length === 0) return pathNotFound(path);
           const aggregated = [];
           for (const candidate of resolved) {
-            const result = await candidate.safeParseAsync(data);
+            let result;
+            try {
+              result = await candidate.safeParseAsync(data);
+            } catch (err) {
+              return validatorThrewResponse(err, path);
+            }
             if (result.success) {
               return {
                 data: result.data,
@@ -1798,6 +1918,22 @@ function zodV4Adapter(rootSchema) {
           }
           return { data: void 0, errors: aggregated, success: false, formKey };
         }
+        function validatorThrewResponse(err, errPath) {
+          const message = err instanceof Error ? err.message : typeof err === "string" ? err : "Validator threw";
+          return {
+            data: void 0,
+            errors: [
+              {
+                message,
+                path: [...errPath],
+                formKey,
+                code: injectWizard.AttaformErrorCode.ValidatorThrew
+              }
+            ],
+            success: false,
+            formKey
+          };
+        }
         function pathNotFound(p) {
           return {
             data: void 0,
@@ -1806,7 +1942,7 @@ function zodV4Adapter(rootSchema) {
                 message: `Path '${p.join(PATH_SEPARATOR)}' did not resolve to any schema`,
                 path: [...p],
                 formKey,
-                code: useFormContext.AttaformErrorCode.PathNotFound
+                code: injectWizard.AttaformErrorCode.PathNotFound
               }
             ],
             success: false,
@@ -1971,6 +2107,7 @@ function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress)
       case "custom":
       case "template-literal":
       case "transform":
+      case "file":
         return;
     }
   } finally {
@@ -1991,7 +2128,7 @@ function resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth) {
   const target = candidates[0];
   if (target === void 0) {
     return {
-      label: useFormContext.humanize(lastSegment),
+      label: injectWizard.humanize(lastSegment),
       description: void 0,
       placeholder: void 0,
       meta: Object.freeze({})
@@ -2005,7 +2142,7 @@ function resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth) {
   const peeledDescription = peeled !== target ? readDescription(peeled) : void 0;
   const schemaDescription = targetDescription ?? peeledDescription;
   return {
-    label: payload?.label ?? useFormContext.humanize(lastSegment),
+    label: payload?.label ?? injectWizard.humanize(lastSegment),
     description: payload?.description ?? schemaDescription ?? void 0,
     placeholder: payload?.placeholder ?? void 0,
     meta: Object.freeze({ ...payload ?? {} })
@@ -2019,10 +2156,10 @@ function readDescription(schema) {
 function useForm(configuration) {
   const candidate = configuration;
   if (candidate === void 0 || candidate === null || candidate.schema === void 0) {
-    throw new plugin.InvalidUseFormConfigError();
+    throw new paths.InvalidUseFormConfigError();
   }
   const adapter = zodV4Adapter(configuration.schema);
-  return useFormContext.useAbstractForm({
+  return injectWizard.useAbstractForm({
     ...configuration,
     schema: adapter
   });
@@ -2035,4 +2172,4 @@ exports.kindOf = kindOf;
 exports.useForm = useForm;
 exports.withMeta = withMeta;
 exports.zodV4Adapter = zodV4Adapter;
-//# sourceMappingURL=attaform.BV40t5y2.cjs.map
+//# sourceMappingURL=attaform.Dlk1jMuv.cjs.map