attaform 0.30.1 → 0.31.1

package/dist/dev/shared/attaform-dev.CwYTWyPX.mjs

@@ -0,0 +1,120 @@
+const reported = /* @__PURE__ */ new Set() ;
+function reportConsumerThrow(site, detail, err) {
+  const key = detail === void 0 ? site : `${site}|${detail}`;
+  if (reported === null || reported.has(key)) return;
+  reported.add(key);
+  const at = detail === void 0 ? "" : ` at \`${detail}\``;
+  const advice = {
+    "default-factory": "a `.default(() => ...)` factory threw. Attaform used `undefined` for that field's initial value.",
+    "catch-factory": "a `.catch(() => ...)` fallback threw. Attaform used `undefined` for that value.",
+    "lazy-getter": "a `z.lazy(() => ...)` factory threw. Attaform stopped descending at that node, so paths below it will not resolve.",
+    "wizard-slot": `a function step slot threw${at}. Attaform dropped that step from the compiled list; the rest of the flow still navigates.`,
+    "wizard-lazy-slot": `a \`lazy()\` step resolver threw${at}. Attaform dropped that step from the compiled list until the resolver's own dependencies change.`,
+    "wizard-progress": "a `useWizard({ progress })` override threw. Attaform fell back to its own valid-step ratio.",
+    "wizard-restore": "a `useWizard({ restore })` callback threw. Attaform read no step from it, so the wizard stays where it is.",
+    "wizard-persist": "a `useWizard({ persist })` callback threw. Attaform navigated anyway, so the step is live but unrecorded.",
+    "wizard-default-statuses": "a `useWizard({ defaultStatuses })` factory threw or rejected. Attaform seeded no statuses, the same as omitting the option.",
+    "stored-value": "a written value threw as Vue read it to store it (a Proxy whose `get` trap throws). Attaform skipped that write, so the form keeps the value it had."
+  };
+  console.error(
+    `[attaform] ${advice[site]} Attaform has nowhere to surface this, so it must not throw; wrap your own try/catch if the failure is recoverable. Original error:`,
+    err
+  );
+}
+function callConsumerFn(fn, fallback, site, detail) {
+  try {
+    return fn();
+  } catch (err) {
+    reportConsumerThrow(site, detail, err);
+    return fallback;
+  }
+}
+function readConsumerProp(obj, key) {
+  try {
+    return obj[key];
+  } catch {
+    return void 0;
+  }
+}
+function consumerKeys(obj) {
+  try {
+    return Object.keys(obj);
+  } catch {
+    return [];
+  }
+}
+function readConsumerIndex(arr, i) {
+  try {
+    return arr[i];
+  } catch {
+    return void 0;
+  }
+}
+function consumerSymbolKeys(obj) {
+  try {
+    return Object.getOwnPropertySymbols(obj);
+  } catch {
+    return [];
+  }
+}
+function consumerHas(obj, key) {
+  try {
+    return key in obj;
+  } catch {
+    return false;
+  }
+}
+
+function safeAssign(target, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+    return;
+  }
+  target[key] = value;
+}
+const SHADOWED_KEYS = new Set(Object.getOwnPropertyNames(Object.prototype));
+function isShadowedKey(key) {
+  return SHADOWED_KEYS.has(key);
+}
+function safeOwnRead(target, key) {
+  if (isShadowedKey(key)) {
+    const desc = Object.getOwnPropertyDescriptor(target, key);
+    if (desc === void 0) return void 0;
+    return "value" in desc ? desc.value : readConsumerProp(target, key);
+  }
+  return readConsumerProp(target, key);
+}
+function safeOwnHas(target, key) {
+  try {
+    return Object.prototype.hasOwnProperty.call(target, key);
+  } catch {
+    return false;
+  }
+}
+function spreadConsumerRecord(src) {
+  try {
+    return { ...src };
+  } catch {
+    const out = {};
+    for (const key of Object.keys(src)) {
+      safeAssign(out, key, readConsumerProp(src, key));
+    }
+    return out;
+  }
+}
+function copyConsumerArray(src) {
+  try {
+    return src.slice();
+  } catch {
+    const out = new Array(src.length);
+    for (let i = 0; i < src.length; i++) out[i] = readConsumerIndex(src, i);
+    return out;
+  }
+}
+
+export { safeOwnRead as a, readConsumerProp as b, consumerKeys as c, callConsumerFn as d, safeOwnHas as e, consumerHas as f, spreadConsumerRecord as g, copyConsumerArray as h, isShadowedKey as i, consumerSymbolKeys as j, reportConsumerThrow as k, readConsumerIndex as r, safeAssign as s };

package/dist/dev/shared/{attaform-dev.DuEE4GU1.mjs → attaform-dev.D7lKyM_7.mjs}

@@ -1,7 +1,7 @@
-import { a as InvalidUseFormConfigError } from './attaform-dev.zlvDr0WB.mjs';
-import { u as useForm$2 } from './attaform-dev.CT7MDjPy.mjs';
-import { u as useForm$1 } from './attaform-dev.BJK1kqHY.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform-dev.BUIFcTYf.mjs';
+import { a as InvalidUseFormConfigError } from './attaform-dev.04aupFBW.mjs';
+import { u as useForm$2 } from './attaform-dev.OceE0X3v.mjs';
+import { u as useForm$1 } from './attaform-dev.BpVGFSFa.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform-dev.PTGM9KE1.mjs';
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;

package/dist/dev/shared/{attaform-dev.CT7MDjPy.mjs → attaform-dev.OceE0X3v.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.BUIFcTYf.mjs';
-import { h as getAtPath, j as humanize, c as useAbstractForm } from './attaform-dev.DxHdkkPG.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';
+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.PTGM9KE1.mjs';
+import { h as getAtPath, j as humanize, c as useAbstractForm } from './attaform-dev.3uTCYwy8.mjs';
+import { d as callConsumerFn } from './attaform-dev.CwYTWyPX.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform-dev.04aupFBW.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;
@@ -335,99 +237,136 @@ 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 = {
@@ -439,10 +378,7 @@ const V3_INTROSPECTOR = {
   getLiteralValues,
   isPreprocessNode,
   isCoercePrimitive,
-  containsAsyncRefine,
-  containsAsyncTransform,
-  containsDiscriminatedUnion,
-  hasContainerOrRootRefine,
+  capabilitiesOf,
   // Walker accessors (D2 / D3 / D5).
   getArrayElement,
   getSetValueType,
@@ -467,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;
@@ -534,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) {
@@ -603,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 });
 }
@@ -678,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);
@@ -817,16 +762,22 @@ 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),
     // The shared path walker peels wrappers and effects inline, so the
@@ -836,6 +787,7 @@ function buildV3Services(maxRecursionDepth) {
     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),
@@ -853,10 +805,10 @@ function buildV3Services(maxRecursionDepth) {
     // 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.
+    // 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 }
     )
@@ -1112,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,
@@ -1124,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) {