attaform 0.27.5 → 0.28.0

package/dist/shared/{attaform.Bh8A6YAc.cjs → attaform.CJP3RkGa.mjs}

@@ -1,58 +1,8 @@
-'use strict';
+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.C09fpdLS.mjs';
+import { o as humanize, h as useAbstractForm } from './attaform.B8k8JrmK.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.wfY8XFvm.mjs';
 
-const walkFieldMeta = require('./attaform.f2zyNh5d.cjs');
-const serializeScript = require('./attaform.Cg1rUfcF.cjs');
-const devtoolsShared = require('./attaform.Biytrv0-.cjs');
-
-const fieldMeta = walkFieldMeta.fieldMetaStore;
-function withMeta(schema, payload) {
-  const existing = walkFieldMeta.getFieldMetaForSchema(schema) ?? {};
-  const Ctor = schema.constructor;
-  const cloned = new Ctor(schema._def);
-  walkFieldMeta.fieldMetaStore.add(cloned, { ...existing, ...payload });
-  return cloned;
-}
-function getFieldMeta(schema) {
-  return walkFieldMeta.getFieldMetaForSchema(schema);
-}
-function getFieldMetaList(schema) {
-  return walkFieldMeta.getFieldMetaListForSchema(schema);
-}
-
-function cloneSchemaDeep(value) {
-  return clone(value, /* @__PURE__ */ new WeakMap());
-}
-function clone(value, seen) {
-  if (value === null || typeof value !== "object") return value;
-  if (seen.has(value)) return seen.get(value);
-  if (value instanceof RegExp) {
-    const copy2 = new RegExp(value.source, value.flags);
-    copy2.lastIndex = value.lastIndex;
-    seen.set(value, copy2);
-    return copy2;
-  }
-  if (value instanceof Date) {
-    const copy2 = new Date(value.getTime());
-    seen.set(value, copy2);
-    return copy2;
-  }
-  if (Array.isArray(value)) {
-    const copy2 = [];
-    seen.set(value, copy2);
-    for (let i = 0; i < value.length; i++) {
-      copy2[i] = clone(value[i], seen);
-    }
-    return copy2;
-  }
-  const copy = Object.create(Object.getPrototypeOf(value));
-  seen.set(value, copy);
-  const source = value;
-  for (const key of Reflect.ownKeys(value)) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    if (descriptor?.enumerable !== true) continue;
-    copy[key] = clone(source[key], seen);
-  }
-  return copy;
+class UnsupportedSchemaError extends AttaformError {
 }
 
 function isZodSchemaType(schema, expectedType) {
@@ -236,12 +186,15 @@ function isAsyncEffect(schema) {
   return fn.constructor.name === "AsyncFunction";
 }
 function containsAsyncRefine(schema, seen) {
-  return walkForAsync(schema, "refinement", seen ?? /* @__PURE__ */ new WeakSet());
+  return walkForTarget(schema, "refinement", seen ?? /* @__PURE__ */ new WeakSet());
+}
+function containsDiscriminatedUnion(schema, seen) {
+  return walkForTarget(schema, "discriminated-union", seen ?? /* @__PURE__ */ new WeakSet());
 }
 function containsAsyncTransform(schema, seen) {
-  return walkForAsync(schema, "transform-or-preprocess", seen ?? /* @__PURE__ */ new WeakSet());
+  return walkForTarget(schema, "transform-or-preprocess", seen ?? /* @__PURE__ */ new WeakSet());
 }
-function walkForAsync(schema, target, visited) {
+function walkForTarget(schema, target, visited) {
   const candidate = schema;
   if (typeof candidate !== "object" || candidate === null) return false;
   if (visited.has(candidate)) return false;
@@ -253,66 +206,69 @@ function walkForAsync(schema, target, visited) {
       return true;
     }
     const inner = unwrapEffectsSource(schema);
-    return inner !== void 0 && walkForAsync(inner, target, visited);
+    return inner !== void 0 && walkForTarget(inner, target, visited);
   }
   if (isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodCatch") || isZodSchemaType(schema, "ZodReadonly")) {
     const inner = unwrapInner(schema);
-    return inner !== void 0 && walkForAsync(inner, target, visited);
+    return inner !== void 0 && walkForTarget(inner, target, visited);
   }
   if (isZodSchemaType(schema, "ZodBranded")) {
     const inner = unwrapBranded(schema);
-    return inner !== void 0 && walkForAsync(inner, target, visited);
+    return inner !== void 0 && walkForTarget(inner, target, visited);
   }
   if (isZodSchemaType(schema, "ZodLazy")) {
     const inner = unwrapLazy(schema);
-    return inner !== void 0 && walkForAsync(inner, target, visited);
+    return inner !== void 0 && walkForTarget(inner, target, visited);
   }
   if (isZodSchemaType(schema, "ZodPipeline")) {
     const inSide = unwrapPipeIn(schema);
-    if (inSide !== void 0 && walkForAsync(inSide, target, visited)) return true;
+    if (inSide !== void 0 && walkForTarget(inSide, target, visited)) return true;
     const outSide = unwrapPipeOut(schema);
-    if (outSide !== void 0 && walkForAsync(outSide, target, visited)) return true;
+    if (outSide !== void 0 && walkForTarget(outSide, target, visited)) return true;
     return false;
   }
   if (isZodSchemaType(schema, "ZodObject")) {
     for (const sub of Object.values(getObjectShape(schema))) {
-      if (walkForAsync(sub, target, visited)) return true;
+      if (walkForTarget(sub, target, visited)) return true;
     }
     return false;
   }
   if (isZodSchemaType(schema, "ZodArray")) {
     const elem = getArrayElement(schema);
-    return elem !== void 0 && walkForAsync(elem, target, visited);
+    return elem !== void 0 && walkForTarget(elem, target, visited);
   }
   if (isZodSchemaType(schema, "ZodTuple")) {
     for (const it of getTupleItems(schema)) {
-      if (walkForAsync(it, target, visited)) return true;
+      if (walkForTarget(it, target, visited)) return true;
     }
     return false;
   }
   if (isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
+    if (target === "discriminated-union" && isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
+      return true;
+    }
     for (const opt of getUnionOptions(schema)) {
-      if (walkForAsync(opt, target, visited)) return true;
+      if (walkForTarget(opt, target, visited)) return true;
     }
     return false;
   }
   if (isZodSchemaType(schema, "ZodIntersection")) {
     const left = getIntersectionLeft(schema);
-    if (left !== void 0 && walkForAsync(left, target, visited)) return true;
+    if (left !== void 0 && walkForTarget(left, target, visited)) return true;
     const right = getIntersectionRight(schema);
-    if (right !== void 0 && walkForAsync(right, target, visited)) return true;
+    if (right !== void 0 && walkForTarget(right, target, visited)) return true;
     return false;
   }
   if (isZodSchemaType(schema, "ZodRecord")) {
     const keyType = getRecordKeyType(schema);
-    if (keyType !== void 0 && walkForAsync(keyType, target, visited)) return true;
+    if (keyType !== void 0 && walkForTarget(keyType, target, visited)) return true;
     const valueType = getRecordValueType(schema);
-    if (valueType !== void 0 && walkForAsync(valueType, target, visited)) return true;
+    if (valueType !== void 0 && walkForTarget(valueType, target, visited)) return true;
     return false;
   }
   if (isZodSchemaType(schema, "ZodSet")) {
     const elem = getSetValueType(schema);
-    return elem !== void 0 && walkForAsync(elem, target, visited);
+    return elem !== void 0 && walkForTarget(elem, target, visited);
   }
   return false;
 }
@@ -349,7 +305,7 @@ function getNativeEnumValues(schema) {
   const def = readDef(schema);
   return def?.values;
 }
-function getDefaultValue$1(schema) {
+function getDefaultValue(schema) {
   const def = readDef(schema);
   const thunk = def?.defaultValue;
   if (typeof thunk !== "function") return void 0;
@@ -373,11 +329,6 @@ function hasCatchValue(schema) {
   const def = readDef(schema);
   return typeof def?.catchValue === "function";
 }
-function hasChecks(schema) {
-  const def = readDef(schema);
-  const checks = def?.checks;
-  return Array.isArray(checks) && checks.length > 0;
-}
 function hasContainerOrRootRefine(schema, seen) {
   const visited = seen ?? /* @__PURE__ */ new WeakSet();
   const candidate = schema;
@@ -473,71 +424,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");
 }
 
-function rebuildWithDef(original, defPatch) {
-  const node = Object.create(Object.getPrototypeOf(original));
-  node._def = { ...original._def, ...defPatch };
-  return node;
-}
-function rebuildObject(original, shape) {
-  const node = rebuildWithDef(original, { shape: () => shape, unknownKeys: "strip" });
-  node._cached = null;
-  return node;
-}
-function rebuildArray(original, element) {
-  return rebuildWithDef(original, {
-    type: element,
-    minLength: null,
-    maxLength: null,
-    exactLength: null
-  });
-}
-function rebuildSet(original, valueType) {
-  return rebuildWithDef(original, {
-    valueType,
-    minSize: null,
-    maxSize: null
-  });
-}
-function rebuildRecord(original, valueType, keyType) {
-  const patch = { valueType };
-  if (keyType !== void 0) patch["keyType"] = keyType;
-  return rebuildWithDef(original, patch);
-}
-function rebuildTuple(original, items) {
-  return rebuildWithDef(original, { items, rest: null });
-}
-function rebuildUnion(original, options) {
-  return rebuildWithDef(original, { options });
-}
-function rebuildIntersection(original, left, right) {
-  return rebuildWithDef(original, { left, right });
-}
-function rebuildWrapperInner(original, inner) {
-  return rebuildWithDef(original, { innerType: inner });
-}
-function rebuildLazy(original, target) {
-  return rebuildWithDef(original, { getter: () => target });
-}
-function stripLeafChecks(original) {
-  return rebuildWithDef(original, { checks: [] });
-}
-function rebuildDiscriminatedUnion(original, options) {
-  const originalOptions = getDiscriminatedOptions(original);
-  const originalMap = getDiscriminatedOptionsMap(original);
-  const optionsMap = /* @__PURE__ */ new Map();
-  if (originalMap !== void 0) {
-    for (const [value, originalOption] of originalMap) {
-      const index = originalOptions.indexOf(originalOption);
-      const replacement = index >= 0 ? options[index] : void 0;
-      if (replacement !== void 0) optionsMap.set(value, replacement);
-    }
-  }
-  return rebuildWithDef(original, { options, optionsMap });
-}
-
-class UnsupportedSchemaError extends devtoolsShared.AttaformError {
-}
-
 const UNSUPPORTED_TYPE_NAMES = /* @__PURE__ */ new Set(["ZodPromise", "ZodFunction", "ZodMap", "ZodSymbol"]);
 function labelPath(path) {
   return path.length === 0 ? "<root>" : path.join(".");
@@ -546,7 +432,7 @@ 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)}'`
+      `[attaform] AF02 attaform.dev/e/af02 '${typeName}' at '${labelPath(path)}'`
     );
   }
   if (isZodSchemaType(schema, "ZodObject")) {
@@ -638,6 +524,7 @@ const V3_INTROSPECTOR = {
   isCoercePrimitive,
   containsAsyncRefine,
   containsAsyncTransform,
+  containsDiscriminatedUnion,
   hasContainerOrRootRefine,
   // Walker accessors (D2 / D3 / D5).
   getArrayElement,
@@ -659,13 +546,72 @@ const V3_INTROSPECTOR = {
   unwrapPipeOut,
   unwrapLazy,
   getLazyGetter,
-  getDefaultValue: getDefaultValue$1,
+  getDefaultValue,
   getCatchDefault,
   hasCatchValue
 };
 
 function slimPrimitivesV3(schema) {
-  return new Set(walkFieldMeta.slimPrimitivesWalk(schema, V3_INTROSPECTOR, 64));
+  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;
+}
+function rebuildObject(original, shape) {
+  const node = rebuildWithDef(original, { shape: () => shape, unknownKeys: "strip" });
+  node._cached = null;
+  return node;
+}
+function rebuildArray(original, element) {
+  return rebuildWithDef(original, {
+    type: element,
+    minLength: null,
+    maxLength: null,
+    exactLength: null
+  });
+}
+function rebuildSet(original, valueType) {
+  return rebuildWithDef(original, {
+    valueType,
+    minSize: null,
+    maxSize: null
+  });
+}
+function rebuildRecord(original, valueType, keyType) {
+  const patch = { valueType };
+  if (keyType !== void 0) patch["keyType"] = keyType;
+  return rebuildWithDef(original, patch);
+}
+function rebuildTuple(original, items) {
+  return rebuildWithDef(original, { items, rest: null });
+}
+function rebuildUnion(original, options) {
+  return rebuildWithDef(original, { options });
+}
+function rebuildIntersection(original, left, right) {
+  return rebuildWithDef(original, { left, right });
+}
+function rebuildWrapperInner(original, inner) {
+  return rebuildWithDef(original, { innerType: inner });
+}
+function rebuildLazy(original, target) {
+  return rebuildWithDef(original, { getter: () => target });
+}
+function rebuildDiscriminatedUnion(original, options) {
+  const originalOptions = getDiscriminatedOptions(original);
+  const originalMap = getDiscriminatedOptionsMap(original);
+  const optionsMap = /* @__PURE__ */ new Map();
+  if (originalMap !== void 0) {
+    for (const [value, originalOption] of originalMap) {
+      const index = originalOptions.indexOf(originalOption);
+      const replacement = index >= 0 ? options[index] : void 0;
+      if (replacement !== void 0) optionsMap.set(value, replacement);
+    }
+  }
+  return rebuildWithDef(original, { options, optionsMap });
 }
 
 function stripAsyncChecks(schema) {
@@ -690,7 +636,7 @@ function stripAsyncChecks(schema) {
     if (isZodSchemaType(s, "ZodDefault")) {
       const inner = unwrapInner(s);
       if (inner === void 0) return s;
-      const def = getDefaultValue$1(s);
+      const def = getDefaultValue(s);
       return recurse(inner).default(def);
     }
     if (isZodSchemaType(s, "ZodCatch")) {
@@ -823,38 +769,17 @@ function carryObjectChecks(rebuilt, original) {
   return next;
 }
 
-const PATH_SEPARATOR = ".";
 const MAX_UNWRAP_STEPS = 64;
-function isPrimitive(input) {
-  const type = typeof input;
-  if (type === "string" || type === "number" || type === "boolean" || type === "bigint" || type === "undefined")
-    return true;
-  return input === null;
-}
-function constraintsAreSlimValid(slimSchema, constraints) {
-  try {
-    return slimSchema.safeParse(constraints).success;
-  } catch {
-    return false;
-  }
-}
-let warnedZodCodeMissing = false;
 function zodAdapter(zodSchema) {
   assertSupportedKinds(zodSchema);
-  const [_strippedRoot] = stripRootSchema(zodSchema, {
-    stripDefaultValues: true,
-    stripNullable: true,
-    stripOptional: true,
-    stripZodEffects: true,
-    stripZodRefinements: true
-  });
-  if (!isZodSchemaType(_strippedRoot, "ZodObject") && !isZodSchemaType(_strippedRoot, "ZodRecord") && !isZodSchemaType(_strippedRoot, "ZodDiscriminatedUnion")) {
-    const name = getTypeName(_strippedRoot);
+  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.`
     );
   }
-  return (formKey, options) => walkFieldMeta.createAbstractSchema(
+  return (formKey, options) => createAbstractSchema(
     zodSchema,
     V3_INTROSPECTOR,
     buildV3Services(),
@@ -863,7 +788,7 @@ function zodAdapter(zodSchema) {
   );
 }
 async function lazyFingerprint(schema) {
-  const { fingerprintZodSchema } = await import('../chunks/fingerprint.cjs');
+  const { fingerprintZodSchema } = await import('../chunks/fingerprint.mjs');
   return fingerprintZodSchema(schema);
 }
 function buildV3Services() {
@@ -874,7 +799,10 @@ function buildV3Services() {
     // slim-mode walks — `getSlimPrimitiveTypesAtPath` and
     // `getSchemasAtPath` both consume this variant so the yielded
     // candidates reflect the slim shape.
-    getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth) => getNestedSchemasInSlimModeV3(schema, path, maxRecursionDepth),
+    // 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),
     slimPrimitivesOf: (schema, _maxRecursionDepth) => slimPrimitivesV3(schema),
     deriveDefault: (schema, useDefault, _maxRecursionDepth, formKey) => getDefaultValuesFromZodSchema(schema, useDefault, formKey),
     runStrictGetDefaults: (schema, config, formKey, maxRecursionDepth) => runStrictGetDefaultsV3(schema, config, formKey, maxRecursionDepth),
@@ -883,7 +811,7 @@ function buildV3Services() {
     peelAllWrappers: (schema) => peelAllV3Wrappers(schema),
     isLeafRequired: (schema) => isLeafRequiredV3(schema),
     resolveFieldMetaAtPath: (schema, path, maxRecursionDepth) => resolveFieldMetaAtPathV3(schema, path, maxRecursionDepth),
-    issuesToValidationErrors: (issues, formKey) => zodIssuesToValidationErrors(issues, formKey),
+    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 };
@@ -896,7 +824,7 @@ function buildV3Services() {
     // 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) => walkFieldMeta.createAbstractSchema(
+    makeSubSchema: (sub, formKey, maxRecursionDepth) => createAbstractSchema(
       sub,
       V3_INTROSPECTOR,
       buildV3Services(),
@@ -905,7 +833,7 @@ function buildV3Services() {
     )
   };
 }
-function zodIssuesToValidationErrors(issues, formKey) {
+function zodIssuesToValidationErrors(issues) {
   const validationErrors = [];
   for (const issue of issues) {
     let code;
@@ -913,12 +841,6 @@ function zodIssuesToValidationErrors(issues, formKey) {
       code = `zod:${issue.code}`;
     } else {
       code = "zod:unknown";
-      if (devtoolsShared.__DEV__ && !warnedZodCodeMissing) {
-        warnedZodCodeMissing = true;
-        console.warn(
-          "[attaform] zod-v3 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."
-        );
-      }
     }
     validationErrors.push({
       message: issue.message,
@@ -934,7 +856,6 @@ function zodIssuesToValidationErrors(issues, formKey) {
       // to absolutise, then routes form-level (absolute path length 0)
       // entries to the empty-string bucket at storage time.
       path: coercePathSegments(issue.path),
-      formKey,
       code
     });
   }
@@ -949,7 +870,7 @@ function coercePathSegments(path) {
 }
 function getNestedZodSchemasAtPath(schema, segments, maxRecursionDepth) {
   if (segments.length === 0) return [schema];
-  return walkFieldMeta.walkPathSegments(schema, segments.map(String), V3_INTROSPECTOR, maxRecursionDepth, 0);
+  return walkPathSegments(schema, segments.map(String), V3_INTROSPECTOR, maxRecursionDepth, 0);
 }
 function unwrapStructuralLeafV3(schema) {
   let current = schema;
@@ -1094,271 +1015,6 @@ function unwrapToDiscriminatedUnion(schema, depth = 0) {
   }
   return void 0;
 }
-function getDefaultValue(expected, context) {
-  const discriminatorContext = context.discriminator;
-  if (discriminatorContext.isDiscriminatorKey) {
-    if (!discriminatorContext.schema) {
-      throw new Error("discriminatorContext.schema unspecified");
-    }
-    if (!isZodSchemaType(discriminatorContext.schema, "ZodDiscriminatedUnion")) {
-      throw new TypeError(
-        "Programming error: discriminatorContext.schema is not a ZodDiscriminatedUnion schema."
-      );
-    }
-    const optionDiscriminator = getSchemaByDiscriminatorKey(
-      discriminatorContext.schema);
-    if (!optionDiscriminator) {
-      throw new Error("ZodDiscriminatedUnion: default option not found");
-    }
-    return getDefaultValuesFromZodSchema(
-      optionDiscriminator,
-      discriminatorContext.useDefaultSchemaValues,
-      context.formKey
-    );
-  }
-  if (expected === "string") return "";
-  if (expected === "number") return 0;
-  if (expected === "array") return [];
-  if (expected === "boolean") return false;
-  if (expected === "bigint") return 0n;
-  if (expected === "float") return 0;
-  if (expected === "integer") return 0;
-  if (expected === "null") return null;
-  if (expected === "object") return {};
-  if (expected === "set") return /* @__PURE__ */ new Set();
-  if (expected === "date") return /* @__PURE__ */ new Date();
-  if (expected === "undefined") return void 0;
-  if (expected === "unknown") return void 0;
-  if (expected === "nan") return Number("nan");
-  return void 0;
-}
-function getDefaultValuesFromZodSchema(formSchema, useDefaultSchemaValues, formKey) {
-  return walkFieldMeta.deriveDefaultWalk(formSchema, useDefaultSchemaValues, V3_INTROSPECTOR, 64, {
-    unsupportedKindFallback: (schema) => {
-      console.warn(
-        `[attaform] zod-v3 adapter: unsupported schema kind '${schema.constructor?.name ?? "unknown"}' on form '${formKey}'. Defaulting the field to null. Use a supported zod kind (object/array/record/string/number/etc.) at this path.`
-      );
-      return null;
-    },
-    // v3 historically surfaces the `.catch(v)` fallback even when
-    // `useDefaultSchemaValues=false`. Pinned by
-    // `test/adapters/zod-v3/wrappers.test.ts` ('surfaces the catch
-    // fallback even when useDefaultSchemaValues is false').
-    catchOnUseDefaultFalse: "preserveCatch"
-  });
-}
-function getSchemaByDiscriminatorKey(unionSchema, key) {
-  if (!isZodSchemaType(unionSchema, "ZodDiscriminatedUnion")) {
-    throw new TypeError("Provided schema is not a discriminated union.");
-  }
-  {
-    const options = getDiscriminatedOptions(unionSchema);
-    if (!options.length) {
-      throw new TypeError("Provided ZodDiscriminatedUnion does not have any options");
-    }
-    return options[0];
-  }
-}
-function stripRefinements(schema) {
-  function _stripRefinements(_schema, depth) {
-    if (depth >= MAX_UNWRAP_STEPS) return _schema;
-    if (isZodSchemaType(_schema, "ZodString") && hasChecks(_schema)) {
-      return stripLeafChecks(_schema);
-    }
-    if (isZodSchemaType(_schema, "ZodNumber") && hasChecks(_schema)) {
-      return stripLeafChecks(_schema);
-    }
-    if (isZodSchemaType(_schema, "ZodArray")) {
-      const inner = getArrayElement(_schema);
-      if (!inner) return _schema;
-      return rebuildArray(_schema, _stripRefinements(inner, depth + 1));
-    }
-    if (isZodSchemaType(_schema, "ZodObject")) {
-      const strippedShape = Object.fromEntries(
-        Object.entries(getObjectShape(_schema)).map(([key, value]) => [
-          key,
-          _stripRefinements(value, depth + 1)
-        ])
-      );
-      return rebuildObject(_schema, strippedShape);
-    }
-    if (isZodSchemaType(_schema, "ZodEffects")) {
-      const inner = unwrapEffectsSource(_schema);
-      if (!inner) return _schema;
-      return _stripRefinements(inner, depth + 1);
-    }
-    if (isZodSchemaType(_schema, "ZodOptional")) {
-      const inner = unwrapInner(_schema);
-      if (!inner) return _schema;
-      return rebuildWrapperInner(_schema, _stripRefinements(inner, depth + 1));
-    }
-    if (isZodSchemaType(_schema, "ZodNullable")) {
-      const inner = unwrapInner(_schema);
-      if (!inner) return _schema;
-      return rebuildWrapperInner(_schema, _stripRefinements(inner, depth + 1));
-    }
-    if (isZodSchemaType(_schema, "ZodReadonly")) {
-      const inner = unwrapInner(_schema);
-      if (!inner) return _schema;
-      return _stripRefinements(inner, depth + 1);
-    }
-    if (isZodSchemaType(_schema, "ZodBranded")) {
-      const inner = unwrapBranded(_schema);
-      if (!inner) return _schema;
-      return _stripRefinements(inner, depth + 1);
-    }
-    if (isZodSchemaType(_schema, "ZodPipeline")) {
-      const inner = unwrapPipeIn(_schema);
-      if (!inner) return _schema;
-      return _stripRefinements(inner, depth + 1);
-    }
-    if (isZodSchemaType(_schema, "ZodSet")) {
-      const valueType = getSetValueType(_schema);
-      if (!valueType) return _schema;
-      return rebuildSet(_schema, _stripRefinements(valueType, depth + 1));
-    }
-    if (isZodSchemaType(_schema, "ZodTuple")) {
-      const items = getTupleItems(_schema);
-      if (items.length === 0) return _schema;
-      const stripped = items.map((it) => _stripRefinements(it, depth + 1));
-      return rebuildTuple(_schema, stripped);
-    }
-    if (isZodSchemaType(_schema, "ZodRecord")) {
-      const valueType = getRecordValueType(_schema);
-      if (!valueType) return _schema;
-      const value = _stripRefinements(valueType, depth + 1);
-      const keyType = getRecordKeyType(_schema);
-      if (keyType) {
-        return rebuildRecord(_schema, value, keyType);
-      }
-      return rebuildRecord(_schema, value);
-    }
-    if (isZodSchemaType(_schema, "ZodUnion")) {
-      const options = getUnionOptions(_schema);
-      if (options.length === 0) return _schema;
-      const stripped = options.map((o) => _stripRefinements(o, depth + 1));
-      return rebuildUnion(_schema, stripped);
-    }
-    if (isZodSchemaType(_schema, "ZodDiscriminatedUnion")) {
-      const discKey = getDiscriminator(_schema);
-      const options = getDiscriminatedOptions(_schema);
-      if (discKey === void 0 || options.length === 0) return _schema;
-      const stripped = options.map(
-        (o) => _stripRefinements(o, depth + 1)
-      );
-      return rebuildDiscriminatedUnion(_schema, stripped);
-    }
-    if (isZodSchemaType(_schema, "ZodIntersection")) {
-      const left = getIntersectionLeft(_schema);
-      const right = getIntersectionRight(_schema);
-      if (!left || !right) return _schema;
-      return rebuildIntersection(
-        _schema,
-        _stripRefinements(left, depth + 1),
-        _stripRefinements(right, depth + 1)
-      );
-    }
-    if (isZodSchemaType(_schema, "ZodLazy")) {
-      const inner = unwrapLazy(_schema);
-      if (!inner) return _schema;
-      const stripped = _stripRefinements(inner, depth + 1);
-      return rebuildLazy(_schema, stripped);
-    }
-    return _schema;
-  }
-  return _stripRefinements(schema, 0);
-}
-function stripRootSchema(schema, stripConfig) {
-  function recursion(_schema, _stripped = false) {
-    if (getStripInstruction(stripConfig.stripNullable, _schema) && isZodSchemaType(_schema, "ZodNullable")) {
-      return recursion(_schema.unwrap(), true);
-    }
-    if (getStripInstruction(stripConfig.stripOptional, _schema) && isZodSchemaType(_schema, "ZodOptional")) {
-      return recursion(_schema.unwrap(), true);
-    }
-    if (getStripInstruction(stripConfig.stripZodEffects, _schema) && isZodSchemaType(_schema, "ZodEffects")) {
-      const inner = unwrapEffectsSource(_schema);
-      if (inner) return recursion(inner, true);
-    }
-    if (getStripInstruction(stripConfig.stripDefaultValues, _schema) && isZodSchemaType(_schema, "ZodDefault")) {
-      const inner = unwrapInner(_schema);
-      if (inner) return recursion(inner, true);
-    }
-    if (getStripInstruction(stripConfig.stripZodRefinements, _schema) && hasChecks(_schema)) {
-      return recursion(stripRefinements(_schema));
-    }
-    return [_schema, _stripped];
-  }
-  return recursion(schema, false);
-}
-const getStripInstruction = (stripValueOrCallback, schema) => {
-  if (stripValueOrCallback === void 0 || stripValueOrCallback === false) return false;
-  return typeof stripValueOrCallback === "function" ? stripValueOrCallback(schema) : stripValueOrCallback;
-};
-function getSlimSchema(config) {
-  function _getSlimSchema(_schema) {
-    if (isZodSchemaType(_schema, "ZodObject")) {
-      const newShape = {};
-      for (const [key, value] of Object.entries(getObjectShape(_schema))) {
-        newShape[key] = _getSlimSchema(value);
-      }
-      return rebuildObject(_schema, newShape);
-    }
-    if (isZodSchemaType(_schema, "ZodArray")) {
-      const inner = getArrayElement(_schema);
-      if (!inner) return _schema;
-      return rebuildArray(_schema, _getSlimSchema(inner));
-    }
-    if (isZodSchemaType(_schema, "ZodRecord")) {
-      const keyType = getRecordKeyType(_schema);
-      const valueType = getRecordValueType(_schema);
-      if (!keyType || !valueType) return _schema;
-      const key = _getSlimSchema(keyType);
-      const value = _getSlimSchema(valueType);
-      return rebuildRecord(_schema, value, key);
-    }
-    if (isZodSchemaType(_schema, "ZodDiscriminatedUnion")) {
-      const slimmedSchemas = [];
-      const discKey = getDiscriminator(_schema);
-      if (discKey === void 0) return _schema;
-      for (const option of getDiscriminatedOptions(_schema)) {
-        const slimmedSchema = _getSlimSchema(option);
-        const deepCloneSlimmedSchema = cloneSchemaDeep(slimmedSchema);
-        slimmedSchemas.push(deepCloneSlimmedSchema);
-      }
-      return rebuildDiscriminatedUnion(
-        _schema,
-        slimmedSchemas
-      );
-    }
-    if (getStripInstruction(config.stripConfig.stripZodEffects, _schema) && isZodSchemaType(_schema, "ZodEffects")) {
-      const inner = unwrapEffectsSource(_schema);
-      if (inner) return _getSlimSchema(inner);
-    }
-    if (getStripInstruction(config.stripConfig.stripNullable, _schema) && isZodSchemaType(_schema, "ZodNullable")) {
-      const inner = unwrapInner(_schema);
-      if (inner) return _getSlimSchema(inner);
-    }
-    if (getStripInstruction(config.stripConfig.stripOptional, _schema) && isZodSchemaType(_schema, "ZodOptional")) {
-      const inner = unwrapInner(_schema);
-      if (inner) return _getSlimSchema(inner);
-    }
-    if (getStripInstruction(config.stripConfig.stripZodRefinements, _schema) && hasChecks(_schema)) {
-      return stripRefinements(_schema);
-    }
-    if (getStripInstruction(config.stripConfig.stripDefaultValues, _schema) && isZodSchemaType(_schema, "ZodDefault")) {
-      const inner = unwrapInner(_schema);
-      if (inner) return _getSlimSchema(inner);
-    }
-    const unionSchema = unwrapToDiscriminatedUnion(_schema);
-    if (unionSchema && getStripInstruction(config.stripConfig.stripDefaultValues, unionSchema)) {
-      return _getSlimSchema(unionSchema);
-    }
-    return _schema;
-  }
-  const processedRootSchema = stripRootSchema(config.schema, config.stripConfig)[0];
-  return _getSlimSchema(processedRootSchema);
-}
 function peelAllV3Wrappers(schema) {
   let current = schema;
   for (let i = 0; i < MAX_UNWRAP_STEPS; i++) {
@@ -1385,30 +1041,41 @@ 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] AF13 attaform.dev/e/af13 '${kindName}' on '${formKey}'`
+      );
+      return null;
+    }
+  });
+}
 function resolveFieldMetaAtPathV3(rootSchema, path, maxRecursionDepth) {
   const lastSegment = path.length === 0 ? "" : path[path.length - 1];
   const target = path.length === 0 ? rootSchema : getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth)[0];
   if (target === void 0) {
     return {
-      label: serializeScript.humanize(lastSegment),
+      label: humanize(lastSegment),
       description: void 0,
       placeholder: void 0,
       meta: Object.freeze({})
     };
   }
-  const pathMap = walkFieldMeta.getFieldMetaPathMap(rootSchema, {
+  const pathMap = buildFieldMetaPathMap(rootSchema, {
     intro: V3_INTROSPECTOR,
     peelAllWrappers: peelAllV3Wrappers,
-    getFieldMetaList
+    getFieldMetaList: getFieldMetaListForSchema
   });
-  const pathKey = devtoolsShared.canonicalizePath(path).key;
+  const pathKey = canonicalizePath(path).key;
   const peeled = peelV3Wrappers(target);
-  const payload = pathMap.get(pathKey) ?? getFieldMeta(target) ?? (peeled !== target ? getFieldMeta(peeled) : void 0);
+  const payload = pathMap?.get(pathKey) ?? getFieldMetaForSchema(target) ?? (peeled !== target ? getFieldMetaForSchema(peeled) : void 0);
   const targetDescription = typeof target.description === "string" ? target.description : void 0;
   const peeledDescription = peeled !== target && typeof peeled.description === "string" ? peeled.description : void 0;
   const schemaDescription = targetDescription ?? peeledDescription;
   return {
-    label: payload?.label ?? serializeScript.humanize(lastSegment),
+    label: payload?.label ?? humanize(lastSegment),
     description: payload?.description ?? schemaDescription ?? void 0,
     placeholder: payload?.placeholder ?? void 0,
     meta: Object.freeze({ ...payload ?? {} })
@@ -1420,24 +1087,7 @@ function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth)
     config.useDefaultSchemaValues,
     formKey
   );
-  const slimSchema = getSlimSchema({
-    schema: rootSchema,
-    stripConfig: {
-      stripZodEffects: true,
-      stripDefaultValues: true,
-      // `strict: false` strips refinements (so empty defaults pass);
-      // strict keeps them so the slim parse below surfaces refinement
-      // errors. Async refines are guarded by the try/catch — they
-      // can't be surfaced synchronously regardless.
-      stripZodRefinements: (config.strict ?? true) === false
-    }
-  });
-  let rawDefaultValues = defaultValuesWithoutConstraints;
-  if (!isPrimitive(rawDefaultValues)) {
-    rawDefaultValues = walkFieldMeta.mergeDeep(defaultValuesWithoutConstraints, config.constraints);
-  } else if (constraintsAreSlimValid(slimSchema, config.constraints)) {
-    rawDefaultValues = config.constraints;
-  }
+  const rawDefaultValues = mergeDeep(defaultValuesWithoutConstraints, config.constraints);
   if ((config.strict ?? true) !== false) {
     if (containsAsyncTransform(rootSchema)) {
       return {
@@ -1459,7 +1109,7 @@ function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth)
       }
       return {
         data: rawDefaultValues,
-        errors: zodIssuesToValidationErrors(strictResult.error.issues, formKey),
+        errors: zodIssuesToValidationErrors(strictResult.error.issues),
         success: false,
         formKey
       };
@@ -1478,7 +1128,7 @@ function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth)
           }
           return {
             data: rawDefaultValues,
-            errors: zodIssuesToValidationErrors(strippedResult.error.issues, formKey),
+            errors: zodIssuesToValidationErrors(strippedResult.error.issues),
             success: false,
             formKey
           };
@@ -1499,139 +1149,40 @@ function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth)
       };
     }
   }
-  let parseResult;
-  try {
-    parseResult = slimSchema.safeParse(rawDefaultValues);
-  } catch {
-    return {
-      data: rawDefaultValues,
-      errors: void 0,
-      success: true,
-      formKey
-    };
-  }
-  const { data, success, error } = parseResult;
-  if (success) {
-    return {
-      data,
-      errors: void 0,
-      success,
-      formKey
-    };
-  }
-  let fixedData = {};
-  for (const issue of error.issues) {
-    const schemasAtPath = getNestedZodSchemasAtPath(slimSchema, issue.path, maxRecursionDepth);
-    const path = coercePathSegments(issue.path);
-    if (!schemasAtPath.length) {
-      console.error(
-        `[attaform] zod-v3 adapter: no schema at path '${path.join(PATH_SEPARATOR)}' for key '${formKey}'. Skipping the issue. (This is a library-internal invariant \u2014 please file a bug.)`
-      );
-      continue;
-    }
-    const candidate = schemasAtPath[0];
-    if (candidate !== void 0) {
-      const valueAtPath = serializeScript.getAtPath(rawDefaultValues, path);
-      const slimKinds = slimPrimitivesV3(candidate);
-      if (slimKinds.size > 0 && slimKinds.has(serializeScript.slimKindOf(valueAtPath))) {
-        continue;
-      }
-    }
-    for (const schemaAtPath of schemasAtPath) {
-      if (issue.code === "invalid_type") {
-        const isDiscriminatedUnion = isZodSchemaType(schemaAtPath, "ZodDiscriminatedUnion");
-        const defaultValueContext = isDiscriminatedUnion ? {
-          formKey,
-          discriminator: {
-            isDiscriminatorKey: true,
-            schema: schemaAtPath,
-            useDefaultSchemaValues: false
-          }
-        } : {
-          formKey,
-          discriminator: {
-            isDiscriminatorKey: false,
-            schema: void 0,
-            useDefaultSchemaValues: false
-          }
-        };
-        const defaultValue = getDefaultValue(issue.expected, defaultValueContext);
-        fixedData = serializeScript.setAtPath(fixedData, path, defaultValue);
-        continue;
-      }
-      const peeled = walkFieldMeta.peelEmbeddedDefault(schemaAtPath, V3_INTROSPECTOR);
-      if (peeled !== walkFieldMeta.NO_EMBEDDED_DEFAULT) {
-        fixedData = serializeScript.setAtPath(fixedData, path, peeled);
-        continue;
-      }
-      const ctx = {
-        formKey,
-        discriminator: {
-          isDiscriminatorKey: false,
-          schema: void 0,
-          useDefaultSchemaValues: false
-        }
-      };
-      const slimKinds = slimPrimitivesV3(schemaAtPath);
-      const firstKind = [...slimKinds][0];
-      if (firstKind !== void 0) {
-        const expected = firstKind === "string" ? "string" : firstKind === "number" ? "number" : firstKind === "boolean" ? "boolean" : firstKind === "bigint" ? "bigint" : firstKind === "date" ? "date" : firstKind === "array" ? "array" : firstKind === "object" ? "object" : null;
-        if (expected !== null) {
-          fixedData = serializeScript.setAtPath(fixedData, path, getDefaultValue(expected, ctx));
-        }
-      }
+  const fixed = fixStructuralDefaults(
+    rootSchema,
+    rawDefaultValues,
+    config.useDefaultSchemaValues,
+    maxRecursionDepth,
+    {
+      intro: V3_INTROSPECTOR,
+      slimPrimitivesOf: (s) => slimPrimitivesV3(s),
+      deriveDefault: (s, useDefault) => getDefaultValuesFromZodSchema(s, useDefault, formKey),
+      unwrapToDiscriminatedUnion: (s) => unwrapToDiscriminatedUnion(s)
     }
-  }
-  fixedData = walkFieldMeta.mergeDeep(rawDefaultValues, fixedData);
-  const secondParse = slimSchema.safeParse(fixedData);
-  const finalData = secondParse.success ? secondParse.data : fixedData;
+  );
   return {
-    data: finalData,
+    data: fixed.data,
     errors: void 0,
     success: true,
     formKey
   };
 }
-const slimRootCacheV3 = /* @__PURE__ */ new WeakMap();
-function getSlimRootV3(rootSchema) {
-  const cached = slimRootCacheV3.get(rootSchema);
-  if (cached !== void 0) return cached;
-  const [strippedSchema] = stripRootSchema(rootSchema, {
-    stripDefaultValues: true,
-    stripNullable: true,
-    stripOptional: true,
-    stripZodEffects: true
-  });
-  const slimSchema = getSlimSchema({
-    schema: strippedSchema,
-    stripConfig: { stripDefaultValues: true, stripZodEffects: true }
-  });
-  slimRootCacheV3.set(rootSchema, slimSchema);
-  return slimSchema;
-}
-function getNestedSchemasInSlimModeV3(rootSchema, path, maxRecursionDepth) {
-  return getNestedZodSchemasAtPath(getSlimRootV3(rootSchema), path, maxRecursionDepth);
-}
 
 function useForm(configuration) {
   if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
-    throw new devtoolsShared.InvalidUseFormConfigError();
+    throw new InvalidUseFormConfigError();
   }
   function isZodType(value) {
     return typeof value === "object" && value !== null && "_def" in value;
   }
   const { schema } = configuration;
   const abstractSchema = isZodType(schema) ? zodAdapter(schema) : schema;
-  return serializeScript.useAbstractForm({
+  return useAbstractForm({
     ...configuration,
     schema: abstractSchema,
     defaultValues: configuration.defaultValues
   });
 }
 
-exports.fieldMeta = fieldMeta;
-exports.isZodSchemaType = isZodSchemaType;
-exports.useForm = useForm;
-exports.withMeta = withMeta;
-exports.zodAdapter = zodAdapter;
-//# sourceMappingURL=attaform.Bh8A6YAc.cjs.map
+export { isZodSchemaType as i, useForm as u, zodAdapter as z };