attaform 0.30.0 → 0.31.0

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

@@ -1,7 +1,7 @@
-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';
+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.Caibt7sb.mjs';
+import { h as getAtPath, j as humanize, c as useAbstractForm } from './attaform-dev.y9x9Vp9F.mjs';
+import { c as callConsumerFn } from './attaform-dev.CZz4GYZ6.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform-dev.zlvDr0WB.mjs';
 
 function isZodSchemaType(schema, expectedType) {
   if (typeof schema !== "object" || schema === null) return false;
@@ -196,104 +196,6 @@ function isAsyncEffect(schema) {
   if (typeof fn !== "function") return false;
   return fn.constructor.name === "AsyncFunction";
 }
-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());
-}
-function containsAsyncTransform(schema, seen) {
-  return walkForTarget(schema, "transform-or-preprocess", seen ?? /* @__PURE__ */ new WeakSet());
-}
-function walkForTarget(schema, target, visited) {
-  const candidate = schema;
-  if (typeof candidate !== "object" || candidate === null) return false;
-  if (visited.has(candidate)) return false;
-  visited.add(candidate);
-  if (isZodSchemaType(schema, "ZodEffects")) {
-    const kind = getEffectsKind(schema);
-    if (target === "refinement" && kind === "refinement") return true;
-    if (target === "transform-or-preprocess" && (kind === "transform" || kind === "preprocess") && isAsyncEffect(schema)) {
-      return true;
-    }
-    const inner = unwrapEffectsSource(schema);
-    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 && walkForTarget(inner, target, visited);
-  }
-  if (isZodSchemaType(schema, "ZodBranded")) {
-    const inner = unwrapBranded(schema);
-    return inner !== void 0 && walkForTarget(inner, target, visited);
-  }
-  if (isZodSchemaType(schema, "ZodLazy")) {
-    const inner = unwrapLazy(schema);
-    return inner !== void 0 && walkForTarget(inner, target, visited);
-  }
-  if (isZodSchemaType(schema, "ZodPipeline")) {
-    const inSide = unwrapPipeIn(schema);
-    if (inSide !== void 0 && walkForTarget(inSide, target, visited)) return true;
-    const outSide = unwrapPipeOut(schema);
-    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 (walkForTarget(sub, target, visited)) return true;
-    }
-    return false;
-  }
-  if (isZodSchemaType(schema, "ZodArray")) {
-    const elem = getArrayElement(schema);
-    return elem !== void 0 && walkForTarget(elem, target, visited);
-  }
-  if (isZodSchemaType(schema, "ZodTuple")) {
-    for (const it of getTupleItems(schema)) {
-      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 (walkForTarget(opt, target, visited)) return true;
-    }
-    return false;
-  }
-  if (isZodSchemaType(schema, "ZodIntersection")) {
-    const left = getIntersectionLeft(schema);
-    if (left !== void 0 && walkForTarget(left, target, visited)) return true;
-    const right = getIntersectionRight(schema);
-    if (right !== void 0 && walkForTarget(right, target, visited)) return true;
-    return false;
-  }
-  if (isZodSchemaType(schema, "ZodRecord")) {
-    const keyType = getRecordKeyType(schema);
-    if (keyType !== void 0 && walkForTarget(keyType, target, visited)) return true;
-    const valueType = getRecordValueType(schema);
-    if (valueType !== void 0 && walkForTarget(valueType, target, visited)) return true;
-    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) {
   const def = readDef(schema);
   return def?.in;
@@ -306,7 +208,7 @@ function unwrapLazy(schema) {
   const def = readDef(schema);
   const getter = def?.getter;
   if (typeof getter !== "function") return void 0;
-  return callConsumerSchemaFn(() => getter(), void 0, "lazy-getter");
+  return callConsumerFn(() => getter(), void 0, "lazy-getter");
 }
 function getLiteralValues(schema) {
   const def = readDef(schema);
@@ -323,115 +225,148 @@ function getDefaultValue(schema) {
   const def = readDef(schema);
   const thunk = def?.defaultValue;
   if (typeof thunk !== "function") return void 0;
-  return callConsumerSchemaFn(() => thunk(), void 0, "default-factory");
+  return callConsumerFn(() => thunk(), void 0, "default-factory");
 }
 function getCatchDefault(schema) {
   const def = readDef(schema);
   const cv = def?.catchValue;
   if (typeof cv !== "function") return void 0;
-  return callConsumerSchemaFn(
-    () => cv({ error: null, input: void 0 }),
-    void 0,
-    "catch-factory"
-  );
+  return callConsumerFn(() => cv({ error: null, input: void 0 }), void 0, "catch-factory");
 }
 function hasCatchValue(schema) {
   const def = readDef(schema);
   return typeof def?.catchValue === "function";
 }
-function hasContainerOrRootRefine(schema, seen) {
-  const visited = seen ?? /* @__PURE__ */ new WeakSet();
+const capabilityMemo = /* @__PURE__ */ new WeakMap();
+function capabilitiesOf(schema) {
+  let capabilities = capabilityMemo.get(schema);
+  if (capabilities === void 0) {
+    capabilities = scanCapabilities(schema);
+    const key = schema;
+    if (typeof key === "object" && key !== null) capabilityMemo.set(key, capabilities);
+  }
+  return capabilities;
+}
+function scanCapabilities(schema) {
+  const capabilities = {
+    asyncRefine: false,
+    asyncTransform: false,
+    discriminatedUnion: false,
+    containerOrRootRefine: false,
+    preprocessOrCoerce: false,
+    mapOrSet: false
+  };
+  walkCapabilities(schema, capabilities, /* @__PURE__ */ new WeakSet());
+  return capabilities;
+}
+function walkCapabilities(schema, capabilities, visited) {
+  if (schema === void 0) return;
   const candidate = schema;
-  if (typeof candidate !== "object" || candidate === null) return false;
-  if (visited.has(candidate)) return false;
+  if (typeof candidate !== "object" || candidate === null || visited.has(candidate)) return;
   visited.add(candidate);
-  if (isZodSchemaType(schema, "ZodEffects")) {
-    const inner = unwrapEffectsSource(schema);
-    if (inner === void 0) return false;
-    if (isContainerAfterWrapperPeel(inner)) return true;
-    return hasContainerOrRootRefine(inner, 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 && hasContainerOrRootRefine(inner, visited);
-  }
-  if (isZodSchemaType(schema, "ZodBranded")) {
-    const inner = unwrapBranded(schema);
-    return inner !== void 0 && hasContainerOrRootRefine(inner, visited);
-  }
-  if (isZodSchemaType(schema, "ZodLazy")) {
-    const inner = unwrapLazy(schema);
-    return inner !== void 0 && hasContainerOrRootRefine(inner, visited);
-  }
-  if (isZodSchemaType(schema, "ZodPipeline")) {
-    const inSide = unwrapPipeIn(schema);
-    if (inSide !== void 0 && hasContainerOrRootRefine(inSide, visited)) return true;
-    const outSide = unwrapPipeOut(schema);
-    if (outSide !== void 0 && hasContainerOrRootRefine(outSide, visited)) return true;
-    return false;
-  }
-  if (isZodSchemaType(schema, "ZodObject")) {
-    for (const sub of Object.values(getObjectShape(schema))) {
-      if (hasContainerOrRootRefine(sub, visited)) return true;
-    }
-    return false;
-  }
-  if (isZodSchemaType(schema, "ZodArray")) {
-    const elem = getArrayElement(schema);
-    return elem !== void 0 && hasContainerOrRootRefine(elem, visited);
-  }
-  if (isZodSchemaType(schema, "ZodTuple")) {
-    for (const it of getTupleItems(schema)) {
-      if (hasContainerOrRootRefine(it, visited)) return true;
-    }
-    return false;
-  }
-  if (isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
-    for (const opt of getUnionOptions(schema)) {
-      if (hasContainerOrRootRefine(opt, visited)) return true;
+  if (isCoercePrimitive(schema)) capabilities.preprocessOrCoerce = true;
+  const typeName = getTypeName(schema) ?? "";
+  switch (typeName) {
+    case "ZodEffects": {
+      const kind = getEffectsKind(schema);
+      if (kind === "refinement") capabilities.asyncRefine = true;
+      else if ((kind === "transform" || kind === "preprocess") && isAsyncEffect(schema)) {
+        capabilities.asyncTransform = true;
+      }
+      if (kind === "preprocess") capabilities.preprocessOrCoerce = true;
+      const inner = unwrapEffectsSource(schema);
+      if (!capabilities.containerOrRootRefine && inner !== void 0 && isContainerAfterWrapperPeel(inner)) {
+        capabilities.containerOrRootRefine = true;
+      }
+      walkCapabilities(inner, capabilities, visited);
+      return;
     }
-    return false;
-  }
-  if (isZodSchemaType(schema, "ZodIntersection")) {
-    const left = getIntersectionLeft(schema);
-    if (left !== void 0 && hasContainerOrRootRefine(left, visited)) return true;
-    const right = getIntersectionRight(schema);
-    if (right !== void 0 && hasContainerOrRootRefine(right, visited)) return true;
-    return false;
-  }
-  if (isZodSchemaType(schema, "ZodRecord")) {
-    const keyType = getRecordKeyType(schema);
-    if (keyType !== void 0 && hasContainerOrRootRefine(keyType, visited)) return true;
-    const valueType = getRecordValueType(schema);
-    if (valueType !== void 0 && hasContainerOrRootRefine(valueType, visited)) return true;
-    return false;
-  }
-  if (isZodSchemaType(schema, "ZodSet")) {
-    const elem = getSetValueType(schema);
-    return elem !== void 0 && hasContainerOrRootRefine(elem, visited);
+    case "ZodOptional":
+    case "ZodNullable":
+    case "ZodDefault":
+    case "ZodCatch":
+    case "ZodReadonly":
+      walkCapabilities(unwrapInner(schema), capabilities, visited);
+      return;
+    case "ZodBranded":
+      walkCapabilities(unwrapBranded(schema), capabilities, visited);
+      return;
+    case "ZodLazy":
+      walkCapabilities(unwrapLazy(schema), capabilities, visited);
+      return;
+    case "ZodPipeline":
+      walkCapabilities(unwrapPipeIn(schema), capabilities, visited);
+      walkCapabilities(unwrapPipeOut(schema), capabilities, visited);
+      return;
+    case "ZodObject":
+      for (const sub of Object.values(getObjectShape(schema))) {
+        walkCapabilities(sub, capabilities, visited);
+      }
+      return;
+    case "ZodArray":
+      walkCapabilities(getArrayElement(schema), capabilities, visited);
+      return;
+    case "ZodTuple":
+      for (const item of getTupleItems(schema)) walkCapabilities(item, capabilities, visited);
+      return;
+    case "ZodUnion":
+    case "ZodDiscriminatedUnion":
+      if (typeName === "ZodDiscriminatedUnion") capabilities.discriminatedUnion = true;
+      for (const option of getUnionOptions(schema)) walkCapabilities(option, capabilities, visited);
+      return;
+    case "ZodIntersection":
+      walkCapabilities(getIntersectionLeft(schema), capabilities, visited);
+      walkCapabilities(getIntersectionRight(schema), capabilities, visited);
+      return;
+    case "ZodRecord":
+      walkCapabilities(getRecordKeyType(schema), capabilities, visited);
+      walkCapabilities(getRecordValueType(schema), capabilities, visited);
+      return;
+    case "ZodSet":
+      capabilities.mapOrSet = true;
+      walkCapabilities(getSetValueType(schema), capabilities, visited);
+      return;
+    case "ZodMap":
+      capabilities.mapOrSet = true;
+      walkCapabilities(getMapKeyType(schema), capabilities, visited);
+      walkCapabilities(getMapValueType(schema), capabilities, visited);
+      return;
   }
-  return false;
 }
+const CONTAINER_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "ZodObject",
+  "ZodArray",
+  "ZodTuple",
+  "ZodIntersection",
+  "ZodUnion",
+  "ZodDiscriminatedUnion",
+  "ZodRecord",
+  "ZodMap",
+  "ZodSet"
+]);
 function isContainerAfterWrapperPeel(schema) {
   let cur = schema;
-  for (let i = 0; i < MAX_UNWRAP_STEPS$1; i++) {
-    if (isZodSchemaType(cur, "ZodOptional") || isZodSchemaType(cur, "ZodNullable") || isZodSchemaType(cur, "ZodDefault") || isZodSchemaType(cur, "ZodCatch") || isZodSchemaType(cur, "ZodReadonly")) {
-      const inner = unwrapInner(cur);
-      if (inner === void 0) return false;
-      cur = inner;
-    } else if (isZodSchemaType(cur, "ZodBranded")) {
-      const inner = unwrapBranded(cur);
-      if (inner === void 0) return false;
-      cur = inner;
-    } else if (isZodSchemaType(cur, "ZodLazy")) {
-      const inner = unwrapLazy(cur);
-      if (inner === void 0) return false;
-      cur = inner;
-    } else {
-      break;
+  for (let i = 0; i < MAX_UNWRAP_STEPS$1 && cur !== void 0; i++) {
+    const typeName = getTypeName(cur) ?? "";
+    switch (typeName) {
+      case "ZodOptional":
+      case "ZodNullable":
+      case "ZodDefault":
+      case "ZodCatch":
+      case "ZodReadonly":
+        cur = unwrapInner(cur);
+        break;
+      case "ZodBranded":
+        cur = unwrapBranded(cur);
+        break;
+      case "ZodLazy":
+        cur = unwrapLazy(cur);
+        break;
+      default:
+        return CONTAINER_TYPE_NAMES.has(typeName);
     }
   }
-  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");
+  return false;
 }
 
 const V3_INTROSPECTOR = {
@@ -443,10 +378,7 @@ const V3_INTROSPECTOR = {
   getLiteralValues,
   isPreprocessNode,
   isCoercePrimitive,
-  containsAsyncRefine,
-  containsAsyncTransform,
-  containsDiscriminatedUnion,
-  hasContainerOrRootRefine,
+  capabilitiesOf,
   // Walker accessors (D2 / D3 / D5).
   getArrayElement,
   getSetValueType,
@@ -471,6 +403,10 @@ const V3_INTROSPECTOR = {
   getCatchDefault,
   hasCatchValue
 };
+const V3_SUB_SCHEMA_INTROSPECTOR = {
+  ...V3_INTROSPECTOR,
+  capabilitiesOf: scanCapabilities
+};
 
 function mapKeyAt(value, index) {
   if (!(value instanceof Map)) return void 0;
@@ -538,7 +474,7 @@ function normalizeOne(path, rootSchema, data, maxRecursionDepth, peel) {
 }
 
 function slimPrimitivesV3(schema) {
-  return new Set(slimPrimitivesWalk(schema, V3_INTROSPECTOR, 64));
+  return slimPrimitivesWalk(schema, V3_INTROSPECTOR, 64);
 }
 
 function rebuildWithDef(original, defPatch) {
@@ -607,6 +543,9 @@ function rebuildDiscriminatedUnion(original, options) {
   }
   return rebuildWithDef(original, { options, optionsMap });
 }
+function rebuildPipeline(original, inSide, outSide) {
+  return rebuildWithDef(original, { in: inSide, out: outSide });
+}
 function rebuildEffects(original, source, effect) {
   return rebuildWithDef(original, { schema: source, effect });
 }
@@ -682,7 +621,9 @@ function walkEffects(schema) {
     }
     if (isZodSchemaType(s, "ZodPipeline")) {
       const inSide = unwrapPipeIn(s);
-      return inSide === void 0 ? s : recurse(inSide);
+      const outSide = unwrapPipeOut(s);
+      if (inSide === void 0 || outSide === void 0) return s;
+      return rebuildPipeline(s, recurse(inSide), recurse(outSide));
     }
     if (isZodSchemaType(s, "ZodObject")) {
       const shape = getObjectShape(s);
@@ -821,29 +762,32 @@ function syncSafe(schema) {
   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 (!issues.some((issue) => issue.path.some((segment) => typeof segment === "number"))) {
+      return issues;
     }
-    if (!hasMapOrSet) return issues;
+    if (!capabilitiesOf(schema).mapOrSet) return issues;
     return normalizeIssuePaths(issues, schema, data, maxRecursionDepth, peelAllV3Wrappers);
   };
+  const validateSync = (schema, data) => {
+    if (capabilitiesOf(schema).asyncTransform) return [];
+    try {
+      const result = syncSafe(schema).safeParse(data);
+      return result.success ? [] : zodIssuesToValidationErrors(refileIssues(schema, data, result.error.issues));
+    } catch {
+      return [];
+    }
+  };
   return {
     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
-    // candidates reflect the slim shape.
-    // 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.
+    // The shared path walker peels wrappers and effects inline, so the
+    // slim and unstripped walks coincide and the root needs no slim
+    // projection of its own. Same aliasing v4 has.
     getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth2) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth2),
     slimPrimitivesOf: (schema, _maxRecursionDepth) => slimPrimitivesV3(schema),
     deriveDefault: (schema, useDefault) => getDefaultValuesFromZodSchema(schema, useDefault),
     runGetDefaults: (schema, config, maxRecursionDepth2) => runGetDefaultsV3(schema, config, maxRecursionDepth2),
+    validateSync,
     unwrapStructuralWrappers: (schema) => unwrapStructuralLeafV3(schema),
     unwrapToDiscriminatedUnion: (schema) => unwrapToDiscriminatedUnion(schema),
     peelAllWrappers: (schema) => peelAllV3Wrappers(schema),
@@ -858,13 +802,13 @@ function buildV3Services(maxRecursionDepth) {
       const result = await schema.safeParseAsync(data);
       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.
+    // A `getSchemasAtPath` consumer may probe any method on the result,
+    // so a sub-schema comes back as a full recursive AbstractSchema: the
+    // factory call rebuilds the whole surface against it, with its own
+    // per-form caches, and walks its capabilities without the memo.
     makeSubSchema: (sub, maxRecursionDepth2) => createAbstractSchema(
       sub,
-      V3_INTROSPECTOR,
+      V3_SUB_SCHEMA_INTROSPECTOR,
       buildV3Services(maxRecursionDepth2),
       { maxRecursionDepth: maxRecursionDepth2 }
     )
@@ -887,17 +831,16 @@ function zodIssuesToValidationErrors(issues) {
     }
     validationErrors.push({
       message: issue.message,
-      // `ValidationError.path` is `(string | number)[]` per the
-      // public type. v3's `issue.path` is the same in the standard
-      // case, but a custom check via `ctx.addIssue({ path: [...] })`
-      // can smuggle a Symbol through — the public surface promised
-      // strings/numbers, so coerce defensively to keep the contract.
-      // Mirrors v4's behaviour at the same site.
+      // `ValidationError.path` is `(string | number)[]` publicly, and
+      // v3's `issue.path` matches in the standard case, but a custom
+      // check calling `ctx.addIssue({ path: [...] })` can smuggle a
+      // Symbol through. Coerce to keep the promise. v4 does the same
+      // here.
       //
-      // Adapter-side paths stay schema-relative — the validation
-      // pipeline in `create-form-store.ts` prepends the parent path
-      // to absolutise, then routes form-level (absolute path length 0)
-      // entries to the empty-string bucket at storage time.
+      // Adapter-side paths stay schema-RELATIVE: the validation pipeline
+      // in `core/create-form-store.ts` prepends the parent path to
+      // absolutise, then routes form-level entries, those whose absolute
+      // path is empty, to the empty-string bucket at storage time.
       path: coercePathSegments(issue.path),
       code
     });
@@ -929,10 +872,10 @@ function unwrapStructuralLeafV3(schema) {
   return current;
 }
 function isStructuralV3Kind(schema) {
-  return isZodSchemaType(schema, "ZodObject") || isZodSchemaType(schema, "ZodArray") || isZodSchemaType(schema, "ZodRecord") || isZodSchemaType(schema, "ZodTuple") || isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion") || // Wrappers that themselves resolve to a structural type — keep
-  // peeling at the next iteration.
-  isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodEffects") || // Newer transparent wrappers (v3.23+). Each wraps a single inner
-  // schema with no structural impact — `peelV3Wrappers` resolves them.
+  return isZodSchemaType(schema, "ZodObject") || isZodSchemaType(schema, "ZodArray") || isZodSchemaType(schema, "ZodRecord") || isZodSchemaType(schema, "ZodTuple") || isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion") || // Wrappers that themselves resolve to a structural type; keep
+  // peeling next iteration.
+  isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodEffects") || // Newer transparent wrappers (v3.23+), each wrapping one inner
+  // schema with no structural impact. `peelV3Wrappers` resolves them.
   isZodSchemaType(schema, "ZodPipeline") || isZodSchemaType(schema, "ZodReadonly") || isZodSchemaType(schema, "ZodBranded");
 }
 function peelV3Wrappers(schema) {
@@ -1121,7 +1064,8 @@ function runGetDefaultsV3(rootSchema, config, maxRecursionDepth) {
     rootSchema,
     config.useDefaultSchemaValues
   );
-  const rawDefaultValues = config.constraints === void 0 ? defaultValuesWithoutConstraints : fixStructuralDefaults(
+  if (config.constraints === void 0) return defaultValuesWithoutConstraints;
+  return fixStructuralDefaults(
     rootSchema,
     mergeDeep(defaultValuesWithoutConstraints, config.constraints),
     config.useDefaultSchemaValues,
@@ -1133,34 +1077,6 @@ function runGetDefaultsV3(rootSchema, config, maxRecursionDepth) {
       unwrapToDiscriminatedUnion: (s) => unwrapToDiscriminatedUnion(s)
     }
   ).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) {