attaform 0.28.0 → 0.30.0

package/dist/dev/shared/{attaform-dev.D2I8e_Mm.mjs → attaform-dev.DTrHonpc.mjs}

@@ -1,9 +1,7 @@
-import { s as slimPrimitivesWalk, c as createAbstractSchema, w as walkPathSegments, d as deriveDefaultWalk, b as buildFieldMetaPathMap, g as getFieldMetaForSchema, m as mergeDeep, f as fixStructuralDefaults, a as getFieldMetaListForSchema } from './attaform-dev.6qxD-Yqo.mjs';
-import { o as humanize, h as useAbstractForm } from './attaform-dev.WmuhD_CZ.mjs';
-import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform-dev.Dr2YzS5B.mjs';
-
-class UnsupportedSchemaError extends AttaformError {
-}
+import { w as walkPathSegments, s as slimPrimitivesWalk, c as createAbstractSchema, a as createSharedSchemaStore, b as buildFieldMetaPathMap, g as getFieldMetaForSchema, f as fixStructuralDefaults, m as mergeDeep, d as deriveDefaultWalk, e as getFieldMetaListForSchema } from './attaform-dev.BisFstxh.mjs';
+import { h as getAtPath, j as humanize, c as useAbstractForm } from './attaform-dev.CQ2rJiAX.mjs';
+import { c as callConsumerSchemaFn } from './attaform-dev.BcYT6tFh.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform-dev.BQc5QV3Y.mjs';
 
 function isZodSchemaType(schema, expectedType) {
   if (typeof schema !== "object" || schema === null) return false;
@@ -123,26 +121,35 @@ function getRecordValueType(schema) {
   const def = readDef(schema);
   return def?.valueType;
 }
+const getMapKeyType = getRecordKeyType;
+const getMapValueType = getRecordValueType;
 function getTupleItems(schema) {
   const def = readDef(schema);
   return def?.items ?? [];
 }
+function readOptionList(options) {
+  if (options === void 0) return [];
+  if (options instanceof Map) return [...options.values()];
+  return [...options];
+}
 function getUnionOptions(schema) {
-  const def = readDef(schema);
-  return def?.options ?? [];
+  return readOptionList(readDef(schema)?.options);
 }
 function getDiscriminatedOptions(schema) {
-  const def = readDef(schema);
-  return def?.options ?? [];
+  return readOptionList(readDef(schema)?.options);
 }
 function getDiscriminator(schema) {
   const def = readDef(schema);
   return def?.discriminator;
 }
 function getDiscriminatedOptionsMap(schema) {
-  const map = readDef(schema)?.optionsMap;
+  const def = readDef(schema);
+  const map = def?.optionsMap ?? def?.options;
   return map instanceof Map ? map : void 0;
 }
+function discriminatedOptionsAreMapped(schema) {
+  return readDef(schema)?.options instanceof Map;
+}
 function getIntersectionLeft(schema) {
   const def = readDef(schema);
   return def?.left;
@@ -163,6 +170,10 @@ function unwrapEffectsSource(schema) {
   const def = readDef(schema);
   return def?.schema;
 }
+function getEffect(schema) {
+  const def = readDef(schema);
+  return def?.effect;
+}
 function getEffectsKind(schema) {
   const def = readDef(schema);
   const type = def?.effect?.type;
@@ -188,6 +199,9 @@ function isAsyncEffect(schema) {
 function containsAsyncRefine(schema, seen) {
   return walkForTarget(schema, "refinement", seen ?? /* @__PURE__ */ new WeakSet());
 }
+function containsMapOrSet(schema, seen) {
+  return walkForTarget(schema, "map-or-set", /* @__PURE__ */ new WeakSet());
+}
 function containsDiscriminatedUnion(schema, seen) {
   return walkForTarget(schema, "discriminated-union", seen ?? /* @__PURE__ */ new WeakSet());
 }
@@ -267,9 +281,17 @@ function walkForTarget(schema, target, visited) {
     return false;
   }
   if (isZodSchemaType(schema, "ZodSet")) {
+    if (target === "map-or-set") return true;
     const elem = getSetValueType(schema);
     return elem !== void 0 && walkForTarget(elem, target, visited);
   }
+  if (isZodSchemaType(schema, "ZodMap")) {
+    if (target === "map-or-set") return true;
+    const keyType = getMapKeyType(schema);
+    if (keyType !== void 0 && walkForTarget(keyType, target, visited)) return true;
+    const valueType = getMapValueType(schema);
+    return valueType !== void 0 && walkForTarget(valueType, target, visited);
+  }
   return false;
 }
 function unwrapPipeIn(schema) {
@@ -284,15 +306,7 @@ function unwrapLazy(schema) {
   const def = readDef(schema);
   const getter = def?.getter;
   if (typeof getter !== "function") return void 0;
-  try {
-    return getter();
-  } catch {
-    return void 0;
-  }
-}
-function getLazyGetter(schema) {
-  const def = readDef(schema);
-  return typeof def?.getter === "function" ? def.getter : void 0;
+  return callConsumerSchemaFn(() => getter(), void 0, "lazy-getter");
 }
 function getLiteralValues(schema) {
   const def = readDef(schema);
@@ -309,21 +323,17 @@ function getDefaultValue(schema) {
   const def = readDef(schema);
   const thunk = def?.defaultValue;
   if (typeof thunk !== "function") return void 0;
-  try {
-    return thunk();
-  } catch {
-    return void 0;
-  }
+  return callConsumerSchemaFn(() => thunk(), void 0, "default-factory");
 }
 function getCatchDefault(schema) {
   const def = readDef(schema);
   const cv = def?.catchValue;
   if (typeof cv !== "function") return void 0;
-  try {
-    return cv({ error: null, input: void 0 });
-  } catch {
-    return void 0;
-  }
+  return callConsumerSchemaFn(
+    () => cv({ error: null, input: void 0 }),
+    void 0,
+    "catch-factory"
+  );
 }
 function hasCatchValue(schema) {
   const def = readDef(schema);
@@ -424,95 +434,6 @@ function isContainerAfterWrapperPeel(schema) {
   return isZodSchemaType(cur, "ZodObject") || isZodSchemaType(cur, "ZodArray") || isZodSchemaType(cur, "ZodTuple") || isZodSchemaType(cur, "ZodIntersection") || isZodSchemaType(cur, "ZodUnion") || isZodSchemaType(cur, "ZodDiscriminatedUnion") || isZodSchemaType(cur, "ZodRecord") || isZodSchemaType(cur, "ZodSet");
 }
 
-const UNSUPPORTED_TYPE_NAMES = /* @__PURE__ */ new Set(["ZodPromise", "ZodFunction", "ZodMap", "ZodSymbol"]);
-function labelPath(path) {
-  return path.length === 0 ? "<root>" : path.join(".");
-}
-function assertSupportedKinds(schema, path = [], lazyGetters = []) {
-  const typeName = getTypeName(schema);
-  if (typeName !== void 0 && UNSUPPORTED_TYPE_NAMES.has(typeName)) {
-    throw new UnsupportedSchemaError(
-      `[attaform/zod-v3] unsupported kind '${typeName}' at '${labelPath(path)}'` 
-    );
-  }
-  if (isZodSchemaType(schema, "ZodObject")) {
-    for (const [key, sub] of Object.entries(getObjectShape(schema))) {
-      assertSupportedKinds(sub, [...path, key], lazyGetters);
-    }
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodArray")) {
-    const inner = getArrayElement(schema);
-    if (inner) assertSupportedKinds(inner, [...path, "*"], lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodSet")) {
-    const inner = getSetValueType(schema);
-    if (inner) assertSupportedKinds(inner, [...path, "*"], lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodRecord")) {
-    const inner = getRecordValueType(schema);
-    if (inner) assertSupportedKinds(inner, [...path, "*"], lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodTuple")) {
-    const items = getTupleItems(schema);
-    items.forEach((item, i) => assertSupportedKinds(item, [...path, String(i)], lazyGetters));
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodUnion")) {
-    const options = getUnionOptions(schema);
-    options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
-    const options = getDiscriminatedOptions(schema);
-    options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodIntersection")) {
-    const left = getIntersectionLeft(schema);
-    if (left) assertSupportedKinds(left, [...path, "left"], lazyGetters);
-    const right = getIntersectionRight(schema);
-    if (right) assertSupportedKinds(right, [...path, "right"], lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodReadonly") || isZodSchemaType(schema, "ZodCatch")) {
-    const inner = unwrapInner(schema);
-    if (inner) assertSupportedKinds(inner, path, lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodBranded")) {
-    const inner = unwrapBranded(schema);
-    if (inner) assertSupportedKinds(inner, path, lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodEffects")) {
-    const inner = unwrapEffectsSource(schema);
-    if (inner) assertSupportedKinds(inner, path, lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodPipeline")) {
-    const inner = unwrapPipeIn(schema);
-    if (inner) assertSupportedKinds(inner, path, lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodLazy")) {
-    const getter = getLazyGetter(schema);
-    if (getter !== void 0 && lazyGetters.includes(getter)) return;
-    const inner = getter?.();
-    if (inner !== void 0) {
-      assertSupportedKinds(
-        inner,
-        path,
-        getter === void 0 ? lazyGetters : [...lazyGetters, getter]
-      );
-    }
-    return;
-  }
-}
-
 const V3_INTROSPECTOR = {
   kindOf: (schema) => kindOf(schema),
   getObjectShape,
@@ -529,8 +450,9 @@ const V3_INTROSPECTOR = {
   // Walker accessors (D2 / D3 / D5).
   getArrayElement,
   getSetValueType,
-  getRecordKeyType,
   getRecordValueType,
+  getMapKeyType: (schema) => kindOf(schema) === "map" ? getMapKeyType(schema) : void 0,
+  getMapValueType: (schema) => kindOf(schema) === "map" ? getMapValueType(schema) : void 0,
   getUnionOptions,
   getIntersectionLeft,
   getIntersectionRight,
@@ -545,20 +467,89 @@ const V3_INTROSPECTOR = {
   unwrapPipeIn,
   unwrapPipeOut,
   unwrapLazy,
-  getLazyGetter,
   getDefaultValue,
   getCatchDefault,
   hasCatchValue
 };
 
+function mapKeyAt(value, index) {
+  if (!(value instanceof Map)) return void 0;
+  if (typeof index !== "number" || !Number.isInteger(index) || index < 0) return void 0;
+  let i = 0;
+  for (const key of value.keys()) {
+    if (i === index) return key;
+    i += 1;
+  }
+  return void 0;
+}
+function stepSchema(schema, segment, maxRecursionDepth) {
+  if (schema === void 0) return void 0;
+  return walkPathSegments(schema, [String(segment)], V3_INTROSPECTOR, maxRecursionDepth, 0)[0];
+}
+function normalizeIssuePaths(issues, rootSchema, data, maxRecursionDepth, peel) {
+  let out = null;
+  for (let i = 0; i < issues.length; i++) {
+    const issue = issues[i];
+    const next = normalizeOne(issue.path, rootSchema, data, maxRecursionDepth, peel);
+    if (next === null) continue;
+    out ?? (out = [...issues]);
+    out[i] = { ...issue, path: next };
+  }
+  return out ?? issues;
+}
+function normalizeOne(path, rootSchema, data, maxRecursionDepth, peel) {
+  const out = [];
+  let schema = rootSchema;
+  let value = data;
+  let changed = false;
+  let i = 0;
+  while (i < path.length) {
+    const peeled = schema === void 0 ? void 0 : peel(schema);
+    const kind = peeled === void 0 ? void 0 : V3_INTROSPECTOR.kindOf(peeled);
+    if (kind === "set") {
+      changed = true;
+      break;
+    }
+    if (kind === "map") {
+      const key = mapKeyAt(value, path[i]);
+      if (key === void 0) {
+        changed = true;
+        break;
+      }
+      if (typeof key !== "string" && typeof key !== "number") {
+        changed = true;
+        break;
+      }
+      out.push(key);
+      value = value.get(key);
+      schema = V3_INTROSPECTOR.getMapValueType(peeled);
+      changed = true;
+      const half = path[i + 1];
+      i += half === "key" || half === "value" ? 2 : 1;
+      continue;
+    }
+    const segment = path[i];
+    out.push(segment);
+    value = getAtPath(value, [segment]);
+    schema = stepSchema(schema, segment, maxRecursionDepth);
+    i += 1;
+  }
+  return changed ? out : null;
+}
+
 function slimPrimitivesV3(schema) {
   return new Set(slimPrimitivesWalk(schema, V3_INTROSPECTOR, 64));
 }
 
 function rebuildWithDef(original, defPatch) {
-  const node = Object.create(Object.getPrototypeOf(original));
-  node._def = { ...original._def, ...defPatch };
-  return node;
+  return Object.create(Object.getPrototypeOf(original), {
+    _def: {
+      value: { ...original._def, ...defPatch },
+      writable: true,
+      enumerable: true,
+      configurable: true
+    }
+  });
 }
 function rebuildObject(original, shape) {
   const node = rebuildWithDef(original, { shape: () => shape, unknownKeys: "strip" });
@@ -611,10 +602,22 @@ function rebuildDiscriminatedUnion(original, options) {
       if (replacement !== void 0) optionsMap.set(value, replacement);
     }
   }
+  if (discriminatedOptionsAreMapped(original)) {
+    return rebuildWithDef(original, { options: optionsMap });
+  }
   return rebuildWithDef(original, { options, optionsMap });
 }
+function rebuildEffects(original, source, effect) {
+  return rebuildWithDef(original, { schema: source, effect });
+}
 
-function stripAsyncChecks(schema) {
+function wrapAsyncSafeRefinements(schema) {
+  return walkEffects(schema);
+}
+function isThenable(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function walkEffects(schema) {
   const seen = /* @__PURE__ */ new WeakSet();
   function recurse(s) {
     const candidate = s;
@@ -623,7 +626,25 @@ function stripAsyncChecks(schema) {
     seen.add(candidate);
     if (isZodSchemaType(s, "ZodEffects")) {
       const inner = unwrapEffectsSource(s);
-      return inner === void 0 ? s : recurse(inner);
+      if (inner === void 0) return s;
+      const effect = getEffect(s);
+      const rebuiltInner = recurse(inner);
+      const original = effect?.["refinement"];
+      if (effect === void 0 || typeof original !== "function") {
+        return rebuildEffects(s, rebuiltInner, effect);
+      }
+      const refine = original;
+      const safeEffect = {
+        ...effect,
+        refinement: (value, ctx) => {
+          const result = refine(value, ctx);
+          if (isThenable(result)) {
+            void result.catch(() => void 0);
+          }
+          return result;
+        }
+      };
+      return rebuildEffects(s, rebuiltInner, safeEffect);
     }
     if (isZodSchemaType(s, "ZodOptional")) {
       const inner = unwrapInner(s);
@@ -772,30 +793,46 @@ function carryObjectChecks(rebuilt, original) {
 const MAX_UNWRAP_STEPS = 64;
 let warnedZodCodeMissing = false;
 function zodAdapter(zodSchema) {
-  assertSupportedKinds(zodSchema);
   const peeledRoot = peelAllV3Wrappers(zodSchema);
   if (!isZodSchemaType(peeledRoot, "ZodObject") && !isZodSchemaType(peeledRoot, "ZodRecord") && !isZodSchemaType(peeledRoot, "ZodDiscriminatedUnion")) {
-    const name = getTypeName(peeledRoot);
-    throw new Error(
-      `Attaform: useForm schema root must be a ZodObject, ZodRecord, or ZodDiscriminatedUnion (got ${name}). Wrap other shapes under a key.`
+    const name = getTypeName(peeledRoot) ?? "unknown";
+    throw new AttaformError(
+      `[attaform/zod-v3] useForm schema root must be a ZodObject, ZodRecord, or ZodDiscriminatedUnion (got '${name}'). Wrap other shapes under a key.` 
     );
   }
-  return (formKey, options) => createAbstractSchema(
+  return (_formKey, options) => sharedV3Schemas(
     zodSchema,
-    V3_INTROSPECTOR,
-    buildV3Services(),
-    formKey,
-    options
+    options.maxRecursionDepth,
+    () => createAbstractSchema(
+      zodSchema,
+      V3_INTROSPECTOR,
+      buildV3Services(options.maxRecursionDepth),
+      options
+    )
   );
 }
-async function lazyFingerprint(schema) {
-  const { fingerprintZodSchema } = await import('../chunks/fingerprint.mjs');
-  return fingerprintZodSchema(schema);
-}
-function buildV3Services() {
+const sharedV3Schemas = createSharedSchemaStore();
+const syncSafeCache = /* @__PURE__ */ new WeakMap();
+function syncSafe(schema) {
+  const cached = syncSafeCache.get(schema);
+  if (cached !== void 0) return cached;
+  const wrapped = wrapAsyncSafeRefinements(schema);
+  syncSafeCache.set(schema, wrapped);
+  return wrapped;
+}
+function buildV3Services(maxRecursionDepth) {
+  const mapOrSetBySchema = /* @__PURE__ */ new WeakMap();
+  const refileIssues = (schema, data, issues) => {
+    let hasMapOrSet = mapOrSetBySchema.get(schema);
+    if (hasMapOrSet === void 0) {
+      hasMapOrSet = containsMapOrSet(schema);
+      mapOrSetBySchema.set(schema, hasMapOrSet);
+    }
+    if (!hasMapOrSet) return issues;
+    return normalizeIssuePaths(issues, schema, data, maxRecursionDepth, peelAllV3Wrappers);
+  };
   return {
-    fingerprint: (schema) => lazyFingerprint(schema),
-    getNestedSchemasAtPath: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
+    getNestedSchemasAtPath: (schema, path, maxRecursionDepth2) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth2),
     // v3 pre-strips refinements / defaults / wrappers off the root for
     // slim-mode walks — `getSlimPrimitiveTypesAtPath` and
     // `getSchemasAtPath` both consume this variant so the yielded
@@ -803,34 +840,33 @@ function buildV3Services() {
     // The slim-root projection is gone (size-teardown P7): the shared
     // path walker peels wrappers / effects inline, so the slim and
     // unstripped walks coincide — same aliasing v4 always had.
-    getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
+    getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth2) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth2),
     slimPrimitivesOf: (schema, _maxRecursionDepth) => slimPrimitivesV3(schema),
-    deriveDefault: (schema, useDefault, _maxRecursionDepth, formKey) => getDefaultValuesFromZodSchema(schema, useDefault, formKey),
-    runStrictGetDefaults: (schema, config, formKey, maxRecursionDepth) => runStrictGetDefaultsV3(schema, config, formKey, maxRecursionDepth),
+    deriveDefault: (schema, useDefault) => getDefaultValuesFromZodSchema(schema, useDefault),
+    runGetDefaults: (schema, config, maxRecursionDepth2) => runGetDefaultsV3(schema, config, maxRecursionDepth2),
     unwrapStructuralWrappers: (schema) => unwrapStructuralLeafV3(schema),
     unwrapToDiscriminatedUnion: (schema) => unwrapToDiscriminatedUnion(schema),
     peelAllWrappers: (schema) => peelAllV3Wrappers(schema),
     isLeafRequired: (schema) => isLeafRequiredV3(schema),
-    resolveFieldMetaAtPath: (schema, path, maxRecursionDepth) => resolveFieldMetaAtPathV3(schema, path, maxRecursionDepth),
+    resolveFieldMetaAtPath: (schema, path, maxRecursionDepth2) => resolveFieldMetaAtPathV3(schema, path, maxRecursionDepth2),
     issuesToValidationErrors: (issues) => zodIssuesToValidationErrors(issues),
     safeParseSync: (schema, data) => {
-      const result = schema.safeParse(data);
-      return result.success ? { success: true, data: result.data } : { success: false, issues: result.error.issues };
+      const result = syncSafe(schema).safeParse(data);
+      return result.success ? { success: true, data: result.data } : { success: false, issues: refileIssues(schema, data, result.error.issues) };
     },
     safeParseAsync: async (schema, data) => {
       const result = await schema.safeParseAsync(data);
-      return result.success ? { success: true, data: result.data } : { success: false, issues: result.error.issues };
+      return result.success ? { success: true, data: result.data } : { success: false, issues: refileIssues(schema, data, result.error.issues) };
     },
     // v3 returns the full recursive AbstractSchema for sub-schemas (the
     // historical shape) — `getSchemasAtPath` consumers may probe any
     // method on the result. The factory call rebuilds the full surface
     // against the sub-schema with its own per-form caches.
-    makeSubSchema: (sub, formKey, maxRecursionDepth) => createAbstractSchema(
+    makeSubSchema: (sub, maxRecursionDepth2) => createAbstractSchema(
       sub,
       V3_INTROSPECTOR,
-      buildV3Services(),
-      formKey,
-      { maxRecursionDepth }
+      buildV3Services(maxRecursionDepth2),
+      { maxRecursionDepth: maxRecursionDepth2 }
     )
   };
 }
@@ -1048,16 +1084,8 @@ function peelAllV3Wrappers(schema) {
   }
   return current;
 }
-function getDefaultValuesFromZodSchema(formSchema, useDefaultSchemaValues, formKey) {
-  return deriveDefaultWalk(formSchema, useDefaultSchemaValues, V3_INTROSPECTOR, 64, {
-    unsupportedKindFallback: (schema) => {
-      const kindName = schema.constructor?.name ?? "unknown";
-      console.warn(
-        `[attaform] zod-v3 adapter: unsupported schema kind '${kindName}' on form '${formKey}'. Defaulting the field to null. Use a supported zod kind (object/array/record/string/number/etc.) at this path.` 
-      );
-      return null;
-    }
-  });
+function getDefaultValuesFromZodSchema(formSchema, useDefaultSchemaValues) {
+  return deriveDefaultWalk(formSchema, useDefaultSchemaValues, V3_INTROSPECTOR, 64);
 }
 function resolveFieldMetaAtPathV3(rootSchema, path, maxRecursionDepth) {
   const lastSegment = path.length === 0 ? "" : path[path.length - 1];
@@ -1088,92 +1116,51 @@ function resolveFieldMetaAtPathV3(rootSchema, path, maxRecursionDepth) {
     meta: Object.freeze({ ...payload ?? {} })
   };
 }
-function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth) {
+function runGetDefaultsV3(rootSchema, config, maxRecursionDepth) {
   const defaultValuesWithoutConstraints = getDefaultValuesFromZodSchema(
     rootSchema,
-    config.useDefaultSchemaValues,
-    formKey
+    config.useDefaultSchemaValues
   );
-  const rawDefaultValues = mergeDeep(defaultValuesWithoutConstraints, config.constraints);
-  if ((config.strict ?? true) !== false) {
-    if (containsAsyncTransform(rootSchema)) {
-      return {
-        data: rawDefaultValues,
-        errors: void 0,
-        success: true,
-        formKey
-      };
-    }
-    try {
-      const strictResult = rootSchema.safeParse(rawDefaultValues);
-      if (strictResult.success) {
-        return {
-          data: rawDefaultValues,
-          errors: void 0,
-          success: true,
-          formKey
-        };
-      }
-      return {
-        data: rawDefaultValues,
-        errors: zodIssuesToValidationErrors(strictResult.error.issues),
-        success: false,
-        formKey
-      };
-    } catch (err) {
-      const isAsyncDetect = err instanceof Error && err.message.includes("Async refinement encountered");
-      if (isAsyncDetect) {
-        try {
-          const strippedResult = stripAsyncChecks(rootSchema).safeParse(rawDefaultValues);
-          if (strippedResult.success) {
-            return {
-              data: rawDefaultValues,
-              errors: void 0,
-              success: true,
-              formKey
-            };
-          }
-          return {
-            data: rawDefaultValues,
-            errors: zodIssuesToValidationErrors(strippedResult.error.issues),
-            success: false,
-            formKey
-          };
-        } catch {
-          return {
-            data: rawDefaultValues,
-            errors: void 0,
-            success: true,
-            formKey
-          };
-        }
-      }
-      return {
-        data: rawDefaultValues,
-        errors: void 0,
-        success: true,
-        formKey
-      };
-    }
-  }
-  const fixed = fixStructuralDefaults(
+  const rawDefaultValues = config.constraints === void 0 ? defaultValuesWithoutConstraints : fixStructuralDefaults(
     rootSchema,
-    rawDefaultValues,
+    mergeDeep(defaultValuesWithoutConstraints, config.constraints),
     config.useDefaultSchemaValues,
     maxRecursionDepth,
     {
       intro: V3_INTROSPECTOR,
       slimPrimitivesOf: (s) => slimPrimitivesV3(s),
-      deriveDefault: (s, useDefault) => getDefaultValuesFromZodSchema(s, useDefault, formKey),
+      deriveDefault: (s, useDefault) => getDefaultValuesFromZodSchema(s, useDefault),
       unwrapToDiscriminatedUnion: (s) => unwrapToDiscriminatedUnion(s)
     }
-  );
-  return {
-    data: fixed.data,
-    errors: void 0,
-    success: true,
-    formKey
-  };
+  ).data;
+  if (containsAsyncTransform(rootSchema)) {
+    return {
+      data: rawDefaultValues,
+      errors: void 0,
+      success: true
+    };
+  }
+  try {
+    const parseResult = syncSafe(rootSchema).safeParse(rawDefaultValues);
+    if (parseResult.success) {
+      return {
+        data: rawDefaultValues,
+        errors: void 0,
+        success: true
+      };
+    }
+    return {
+      data: rawDefaultValues,
+      errors: zodIssuesToValidationErrors(parseResult.error.issues),
+      success: false
+    };
+  } catch {
+    return {
+      data: rawDefaultValues,
+      errors: void 0,
+      success: true
+    };
+  }
 }
 
 function useForm(configuration) {

package/dist/dev/shared/{attaform-dev.BXE2cr0L.mjs → attaform-dev.DUZckyV8.mjs}

@@ -1,4 +1,4 @@
-import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform-dev.Dr2YzS5B.mjs';
+import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform-dev.BQc5QV3Y.mjs';
 import { shallowReactive, getCurrentInstance, inject } from 'vue';
 
 function detectSSR(options = {}) {
@@ -17,7 +17,6 @@ const kFormContext = /* @__PURE__ */ Symbol.for("attaform:form-context");
 const kFormInstanceId = /* @__PURE__ */ Symbol.for("attaform:form-instance-id");
 function createRegistry(options = {}) {
   const ssr = detectSSR(options);
-  const defaults = Object.freeze({ ...options.defaults ?? {} });
   const forms = shallowReactive(/* @__PURE__ */ new Map());
   const wizards = shallowReactive(/* @__PURE__ */ new Map());
   const pendingHydration = shallowReactive(/* @__PURE__ */ new Map());
@@ -102,7 +101,6 @@ function createRegistry(options = {}) {
     wizards,
     pendingHydration,
     ssr,
-    defaults,
     trackConsumer,
     trackWizardConsumer,
     enqueuePrefetch,

package/dist/dev/zod-v3.mjs

@@ -1,9 +1,9 @@
-export { i as isZodSchemaType, u as useForm, z as zodAdapter } from './shared/attaform-dev.D2I8e_Mm.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform-dev.6qxD-Yqo.mjs';
-export { A as AttaformError, I as InvalidPathError, a as InvalidUseFormConfigError, O as OutsideSetupError, R as ROOT_PATH, b as ROOT_PATH_KEY, c as RegistryNotInstalledError, d as ReservedFormKeyError, S as SubmitErrorHandlerError, e as canonicalizePath, i as isPathPrefix, p as parseDottedPath } from './shared/attaform-dev.Dr2YzS5B.mjs';
-export { A as AttaformErrorCode, D as DEFAULT_TIMINGS, d as defaultCoercionRules, a as defaultDisplayState, b as defineCoercion, e as escapeForInlineScript, g as gate, i as injectForm, c as injectWizard, f as isUnset, l as lazy, m as makeDefaultDisplayState, u as unset, j as useRegister, k as useWizard } from './shared/attaform-dev.WmuhD_CZ.mjs';
-export { D as DEVTOOLS_WINDOW_KEY, c as createAttaform, a as createRegistry, g as getRegistryFromApp, h as hydrateAttaformState, k as kAttaformRegistry, r as renderAttaformState, u as useRegistry } from './shared/attaform-dev.BXE2cr0L.mjs';
-export { a as assignKey, i as isRegisterValue, v as vRegister } from './shared/attaform-dev.P7cseiEG.mjs';
+export { i as isZodSchemaType, u as useForm, z as zodAdapter } from './shared/attaform-dev.DTrHonpc.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform-dev.BisFstxh.mjs';
+export { A as AttaformError, I as InvalidPathError, a as InvalidUseFormConfigError, O as OutsideSetupError, R as ROOT_PATH, b as ROOT_PATH_KEY, c as RegistryNotInstalledError, d as ReservedFormKeyError, S as SubmitErrorHandlerError, e as canonicalizePath, i as isPathPrefix, p as parseDottedPath } from './shared/attaform-dev.BQc5QV3Y.mjs';
+export { A as AttaformErrorCode, e as escapeForInlineScript, g as gate, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, d as useRegister, f as useWizard } from './shared/attaform-dev.CQ2rJiAX.mjs';
+export { D as DEVTOOLS_WINDOW_KEY, c as createAttaform, a as createRegistry, g as getRegistryFromApp, h as hydrateAttaformState, k as kAttaformRegistry, r as renderAttaformState, u as useRegistry } from './shared/attaform-dev.DUZckyV8.mjs';
+export { a as assignKey, i as isRegisterValue, v as vRegister } from './shared/attaform-dev.D6CLvaQT.mjs';
 
 const fieldMeta = installingFieldMetaStore;
 function withMeta(schema, payload) {