attaform 0.30.0 → 0.31.0

package/dist/runtime/components/AttaformDevtoolsPanel.vue

@@ -5,7 +5,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
   // can resolve through the consumer's node_modules → `dist/index.mjs`,
   // rather than through brittle relative paths into the rollup-bundled
   // shared chunks (which mkdist doesn't co-locate). Type-only imports of
-  // internal types stay relative — they're erased at compile time and
+  // internal types stay relative: they're erased at compile time and
   // don't need to resolve at the consumer's runtime.
   import { type AttaformDevtoolsBridge, canonicalizePath, type Segment } from 'attaform'
   import type { FormStore } from '../core/create-form-store'
@@ -18,7 +18,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
   }>()
 
   // Cross-iframe reactivity bridge. Vue's reactivity system is module-
-  // scoped — the host's `@vue/reactivity` instance and the panel's are
+  // scoped: the host's `@vue/reactivity` instance and the panel's are
   // different copies of the same module, each with its own targetMap.
   // When the panel reads `host.form.value` in a `computed`, the proxy's
   // get trap runs in the host's tracking context (the function lives
@@ -31,7 +31,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
   // (`onFormChange` / `onSubmitSuccess` / `onReset`), plus a 250ms
   // polling fallback for state that changes outside those events (user
   // errors via `setErrors`, submit-lifecycle flags). The panel's
-  // own reactivity then re-evaluates everything in one pass — cheap
+  // own reactivity then re-evaluates everything in one pass, cheap
   // because the underlying reads are direct property accesses.
   const updateTick = ref(0)
 
@@ -72,7 +72,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
     void updateTick.value
     const form = activeForm.value
     if (form === null) return []
-    return Array.from(form.errorCells.entries())
+    return Array.from(form.errorCells().entries())
       .filter(([, cell]) => cell.schema.length > 0)
       .map(([key, cell]) => [key, cell.schema] as const)
   })
@@ -81,7 +81,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
     void updateTick.value
     const form = activeForm.value
     if (form === null) return []
-    return Array.from(form.errorCells.entries())
+    return Array.from(form.errorCells().entries())
       .filter(([, cell]) => cell.user.length > 0)
       .map(([key, cell]) => [key, cell.user] as const)
   })
@@ -120,7 +120,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
   }
 
   /**
-   * Render a JS value as a debug-friendly string with no masking —
+   * Render a JS value as a debug-friendly string with no masking,
    * `null` / `undefined` show as their literal names, booleans and
    * numbers as-is, strings bare (no surrounding quotes), everything
    * else JSON-stringified. Devtools is for inspecting state, not for
@@ -169,13 +169,13 @@ import { computed, onUnmounted, ref, watch } from 'vue'
   /**
    * Raw field data at the selected path, composed from `FormStore`
    * primitives. The callable `form.fields(path)` proxy lives on the
-   * public `useForm` return, not on `FormStore` — the bridge exposes
+   * public `useForm` return, not on `FormStore`: the bridge exposes
    * the store, so we synthesise the same data from `fields.get(key)`
    * + the error Maps + an inline value walk.
    *
    * Returns the raw `FieldRecord` (updatedAt / focused / blurred /
    * touched / connected) rather than the wrapped `FieldState`
-   * surface. Sufficient for inspection — the full aggregated
+   * surface. Sufficient for inspection: the full aggregated
    * FieldState would require either lifting the surface-proxy into
    * `FormStore` (architectural change) or rebuilding the aggregation
    * walker in the panel (duplication).
@@ -211,7 +211,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
           | undefined) ?? null
 
       // Inline path walk (avoids importing path-walker through the
-      // bridge — it lives in the host's shared chunk).
+      // bridge: it lives in the host's shared chunk).
       let value: unknown = form.form.value
       for (const seg of path) {
         if (value === null || typeof value !== 'object') {
@@ -221,7 +221,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
         value = (value as Record<string | number, unknown>)[seg]
       }
 
-      const cell = form.errorCells.get(canonicalKey)
+      const cell = form.errorCells().get(canonicalKey)
       const schemaEntries =
         (cell?.schema as ReadonlyArray<{ message: string; code: string }> | undefined) ?? []
       const userEntries =
@@ -259,7 +259,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
       const { segments: canonicalPath } = canonicalizePath(rawPath as readonly Segment[])
       form.setValueAtPath(canonicalPath, next)
       // The host's setValueAtPath fires `onFormChange` listeners, which
-      // bumps our updateTick (see subscribeForm) — that refreshes the
+      // bumps our updateTick (see subscribeForm): that refreshes the
       // panel's view of the new value on the next microtask.
     } catch (err) {
       // Surface cross-iframe write failures (e.g., type-instance checks
@@ -285,7 +285,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
 
   /**
    * Hard cap on the in-memory event log. Sized for a debugging session,
-   * not an audit log — older events fall off the back when capacity
+   * not an audit log, older events fall off the back when capacity
    * fills. Tunable later if real consumers ask for more.
    */
   const MAX_TIMELINE_EVENTS = 200
@@ -325,7 +325,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
 
   function subscribeForm(key: FormKey, form: FormStore<GenericForm>): void {
     if (subscribers.has(key)) return
-    // Deep-clone the form value at the moment of fire — FormStore
+    // Deep-clone the form value at the moment of fire, FormStore
     // mutates form data in place, so a stored reference would update
     // every existing timeline entry whenever the form changed again
     // ("type a, delete a, both timeline events show the empty value"
@@ -336,7 +336,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
       try {
         return structuredClone(form.form.value)
       } catch {
-        // Non-cloneable values (functions, Symbols, Vue refs, etc.) —
+        // Non-cloneable values (functions, Symbols, Vue refs, etc.),
         // fall back to the live reference. Worst case: that one entry
         // still shows the current state, same as before this fix.
         return form.form.value
@@ -379,7 +379,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
   )
 
   // Polling fallback for state that changes outside the `onFormChange` /
-  // `onSubmitSuccess` / `onReset` event surface — user errors injected
+  // `onSubmitSuccess` / `onReset` event surface, user errors injected
   // via `setErrors`, submit-lifecycle flags between events, or
   // new forms registered in the host's registry. 120ms is faster than
   // a human can notice between an input event and a visible panel

package/dist/runtime/components/DevtoolsValueTree.vue

@@ -100,7 +100,7 @@ import { computed, nextTick, ref } from 'vue'
     // Array indices arrive as stringified numbers from `Object.entries` /
     // `array.map`. Coerce back to numbers when the parent is an array
     // so `canonicalizePath` on the consumer side gets a structured Path
-    // with the right shape — `["users", 0, "name"]`, not
+    // with the right shape, `["users", 0, "name"]`, not
     // `["users", "0", "name"]`.
     if (type.value === 'array') return [...path.value, Number(rawKey)]
     return [...path.value, rawKey]
@@ -159,7 +159,7 @@ import { computed, nextTick, ref } from 'vue'
 
   // Selection (Field-state inspector hook). Canonical key uses JSON-
   // serialised path-array form so two arrays with the same shape produce
-  // the same string — direct equality check.
+  // the same string, direct equality check.
   const ownKey = computed(() => JSON.stringify(path.value))
   const isSelected = computed(
     () =>

package/dist/runtime/plugins/attaform.mjs

@@ -1,5 +1,5 @@
 import { defineNuxtPlugin, useRuntimeConfig, useRoute } from 'nuxt/app';
-import { c as createAttaform, b as kAttaformWizardActiveStepResolver, r as renderAttaformState, h as hydrateAttaformState, g as getRegistryFromApp, D as DEVTOOLS_WINDOW_KEY } from '../../shared/attaform.WiGdIqgx.mjs';
+import { c as createAttaform, b as kAttaformWizardActiveStepResolver, r as renderAttaformState, h as hydrateAttaformState, g as getRegistryFromApp, D as DEVTOOLS_WINDOW_KEY } from '../../shared/attaform.C4shmwyJ.mjs';
 
 var attaform_default = defineNuxtPlugin({
   // `enforce: 'pre'` makes the "we run before any component's setup" claim

package/dist/shared/{attaform.BRDDQeHV.mjs → attaform.8mfKZCwH.mjs}

@@ -21,7 +21,7 @@ function pickDefined(bag) {
   return out;
 }
 
-function callConsumerSchemaFn(fn, fallback, site) {
+function callConsumerFn(fn, fallback, site, detail) {
   try {
     return fn();
   } catch (err) {
@@ -355,4 +355,4 @@ function structuralSnapshot(value) {
   return out;
 }
 
-export { ANONYMOUS_FORM_KEY_PREFIX as A, DEFAULT_HISTORY_MAX_SNAPSHOTS as D, RESERVED_KEY_PREFIX as R, safeOwnRead as a, safeAssign as b, callConsumerSchemaFn as c, safeOwnHas as d, consumerHas as e, spreadConsumerRecord as f, copyConsumerArray as g, consumerKeys as h, isShadowedKey as i, readConsumerProp as j, diffAndApply as k, DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS as l, consumerSymbolKeys as m, normalizeNumericOption as n, applyChangedKeys as o, pickDefined as p, DEFAULT_MAX_RECURSION_DEPTH as q, readConsumerIndex as r, structuralSnapshot as s, ANONYMOUS_WIZARD_KEY_PREFIX as t };
+export { ANONYMOUS_FORM_KEY_PREFIX as A, DEFAULT_HISTORY_MAX_SNAPSHOTS as D, RESERVED_KEY_PREFIX as R, safeOwnRead as a, safeAssign as b, callConsumerFn as c, safeOwnHas as d, consumerHas as e, spreadConsumerRecord as f, copyConsumerArray as g, consumerKeys as h, isShadowedKey as i, readConsumerProp as j, diffAndApply as k, DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS as l, consumerSymbolKeys as m, normalizeNumericOption as n, applyChangedKeys as o, pickDefined as p, DEFAULT_MAX_RECURSION_DEPTH as q, readConsumerIndex as r, structuralSnapshot as s, ANONYMOUS_WIZARD_KEY_PREFIX as t };

package/dist/shared/{attaform.DRUT703x.d.mts → attaform.B-Tb62qV.d.mts}

@@ -18,19 +18,19 @@ import { z } from 'zod';
 type SupportedRootSchema = z.ZodObject<z.ZodRawShape> | z.ZodRecord<z.ZodTypeAny, z.ZodTypeAny> | z.ZodDiscriminatedUnion<string, readonly z.ZodDiscriminatedUnionOption<string>[]>;
 
 /**
- * v3 mirror of the Zod v4 `StorageShape`. Per top-level key, default
- * to `z.output<Shape[K]>` (the post-init view — defaults have fired,
- * Zod's own recursion peels nested defaults inside structural
- * containers); fall back to `z.input<Shape[K]>` for transform / pipe
- * carriers (`ZodEffects`, `ZodPipeline`) where storage holds the
- * pre-transform input — transforms only run at submission /
- * validation, not at the write boundary.
+ * The v3 mirror of Zod v4's `StorageShape`. Each top-level key defaults
+ * to `z.output<Shape[K]>`, the post-init view, where defaults have fired
+ * and Zod's own recursion has peeled nested defaults inside structural
+ * containers. A transform or pipe carrier (`ZodEffects`, `ZodPipeline`)
+ * falls back to `z.input<Shape[K]>`, storage there holding the
+ * pre-transform input: a transform runs at submission or validation, not
+ * at the write boundary.
  *
- * v3 quirk: `ZodEffects` covers BOTH `.transform()` and
- * `z.preprocess()` at the TS level — v3 doesn't carry a separate
- * preprocess class the way v4 does. Deferring to `z.input` for
- * `ZodEffects` means a top-level `z.preprocess(fn, T)` leaf reads as
- * the preprocess input (commonly `unknown`); reach for the
+ * A v3 quirk sharpens this: `ZodEffects` covers BOTH `.transform()` and
+ * `z.preprocess()` at the TS level, v3 carrying no separate preprocess
+ * class. So deferring to `z.input` there makes a top-level
+ * `z.preprocess(fn, T)` leaf read as the preprocess input, commonly
+ * `unknown`; reach for the
  * `AbstractSchema` escape hatch if a stronger type is needed.
  * Transforms preserve their pre-transform input shape, which matches
  * storage.

package/dist/shared/{attaform.v0fQtWyA.mjs → attaform.B1rH9ht6.mjs}

@@ -1,4 +1,4 @@
-import { r as resolveZodAliasTarget, i as isRewritableZodSpecifier } from './attaform.DhnPb6nK.mjs';
+import { r as resolveZodAliasTarget, i as isRewritableZodSpecifier } from './attaform.BAf3UNn4.mjs';
 
 const TAP_NAME = "attaform";
 function createWebpackFamilyPlugin(tag, options) {

package/dist/shared/{attaform.DhnPb6nK.mjs → attaform.BAf3UNn4.mjs}

@@ -32,7 +32,7 @@ function missingZodError(tag) {
   return `[${tag}] zod is not installed. attaform requires zod as a peer dependency. Install \`zod@^3\` or \`zod@^4\`, OR pass \`attaform({ resolveZodAlias: false })\` to keep the runtime-dispatch unified entry (and silence this check).`;
 }
 function unclassifiableZodWarning(tag) {
-  return `[${tag}] Could not classify the installed Zod major (corrupted package.json, monorepo edge case, or an unexpected version string). Falling through to runtime dispatch \u2014 both Zod adapters will ship in the bundle. Pass \`attaform({ resolveZodAlias: false })\` to silence this warning.`;
+  return `[${tag}] Could not classify the installed Zod major (corrupted package.json, monorepo edge case, or an unexpected version string). Falling through to runtime dispatch, so both Zod adapters will ship in the bundle. Pass \`attaform({ resolveZodAlias: false })\` to silence this warning.`;
 }
 function resolveZodAliasTarget(consumerRootDir, tag, resolveZodAlias, warnState) {
   if (!resolveZodAlias) return null;

package/dist/shared/{attaform.BXneBxEj.mjs → attaform.BWUn8Kjy.mjs}

@@ -1,7 +1,7 @@
-import { j as humanize, c as useAbstractForm } from './attaform.DNJOWjQw.mjs';
+import { j as humanize, c as useAbstractForm } from './attaform.DNPJPOO7.mjs';
 import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.CdZIEf7_.mjs';
-import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, a as createSharedSchemaStore, b as buildFieldMetaPathMap, e as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform.CUfrMK7t.mjs';
-import { c as callConsumerSchemaFn } from './attaform.BRDDQeHV.mjs';
+import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, a as createSharedSchemaStore, b as buildFieldMetaPathMap, e as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform.DL2nl_QR.mjs';
+import { c as callConsumerFn } from './attaform.8mfKZCwH.mjs';
 
 function readDef(schema) {
   if (schema === null || typeof schema !== "object") return void 0;
@@ -119,9 +119,7 @@ function isCoercePrimitive(schema) {
   return readDef(schema)?.coerce === true;
 }
 function isPreprocessNode(schema) {
-  if (kindOf(schema) !== "pipe") return false;
-  const pipeIn = unwrapPipeIn(schema);
-  return pipeIn !== void 0 && kindOf(pipeIn) === "transform";
+  return kindOf(schema) === "pipe" && kindOf(readDef(schema)?.in) === "transform";
 }
 function unwrapPipeOut(schema) {
   const def = readDef(schema);
@@ -131,7 +129,7 @@ function unwrapLazy(schema) {
   const def = readDef(schema);
   const getter = def?.getter;
   if (typeof getter !== "function") return void 0;
-  return callConsumerSchemaFn(() => getter(), void 0);
+  return callConsumerFn(() => getter(), void 0);
 }
 function getIntersectionLeft(schema) {
   const def = readDef(schema);
@@ -145,7 +143,7 @@ function getCatchDefault(schema) {
   const def = readDef(schema);
   const cv = def?.catchValue;
   if (typeof cv !== "function") return void 0;
-  return callConsumerSchemaFn(
+  return callConsumerFn(
     () => cv({ error: new Error("atta:default-values"), input: void 0 }),
     void 0);
 }
@@ -155,7 +153,7 @@ function hasCatchValue(schema) {
 }
 function getDefaultValue(schema) {
   const def = readDef(schema);
-  return callConsumerSchemaFn(() => def?.defaultValue, void 0);
+  return callConsumerFn(() => def?.defaultValue, void 0);
 }
 function getNativeEnumValues(_schema) {
   return void 0;
@@ -200,60 +198,6 @@ const DESCEND_SINGLE = [
 ];
 const DESCEND_RECORD = ["shape", "entries"];
 const DESCEND_LIST = ["options", "items"];
-function walkSchemaTree(schema, visit, seen) {
-  const visited = seen ?? /* @__PURE__ */ new WeakSet();
-  const candidate = schema;
-  if (typeof candidate !== "object" || candidate === null) return false;
-  if (visited.has(candidate)) return false;
-  visited.add(candidate);
-  if (visit(schema)) return true;
-  const def = readDef(schema);
-  if (def === void 0) return false;
-  const slots = def;
-  for (const key of DESCEND_SINGLE) {
-    const child = slots[key];
-    if (child !== void 0 && walkSchemaTree(child, visit, visited)) return true;
-  }
-  for (const key of DESCEND_RECORD) {
-    const record = slots[key];
-    if (record !== void 0) {
-      for (const sub of Object.values(record)) {
-        if (walkSchemaTree(sub, visit, visited)) return true;
-      }
-    }
-  }
-  for (const key of DESCEND_LIST) {
-    const list = slots[key];
-    if (list !== void 0) {
-      for (const sub of list) {
-        if (walkSchemaTree(sub, visit, visited)) return true;
-      }
-    }
-  }
-  if (typeof def.getter === "function") {
-    try {
-      const inner = def.getter();
-      if (walkSchemaTree(inner, visit, visited)) return true;
-    } catch {
-    }
-  }
-  return false;
-}
-function containsDiscriminatedUnion(schema, seen) {
-  return walkSchemaTree(schema, (node) => kindOf(node) === "discriminated-union", seen);
-}
-function containsAsyncRefine(schema, seen) {
-  return walkSchemaTree(
-    schema,
-    (node) => {
-      for (const check of getChecks(node)) {
-        if (isAsyncCheck(check)) return true;
-      }
-      return false;
-    },
-    seen
-  );
-}
 const CONTAINER_SLOTS = [
   "shape",
   "entries",
@@ -265,31 +209,55 @@ const CONTAINER_SLOTS = [
   "left",
   "right"
 ];
-function hasContainerOrRootRefine(schema, seen) {
-  return walkSchemaTree(
-    schema,
-    (node) => {
-      const def = readDef(node);
-      if (def === void 0) return false;
-      const slots = def;
-      if (!CONTAINER_SLOTS.some((key) => slots[key] !== void 0)) return false;
-      return getChecks(node).length > 0;
-    },
-    seen
-  );
-}
-function containsAsyncTransform(schema, seen) {
-  return walkSchemaTree(
-    schema,
-    (node) => {
-      const def = readDef(node);
-      if (def === void 0) return false;
-      const fn = def.transform;
-      if (typeof fn !== "function") return false;
-      return fn.constructor.name === "AsyncFunction";
-    },
-    seen
-  );
+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
+  };
+  walkCapabilities(schema, capabilities, /* @__PURE__ */ new WeakSet());
+  return capabilities;
+}
+function walkCapabilities(node, capabilities, visited) {
+  if (typeof node !== "object" || node === null || visited.has(node)) return;
+  visited.add(node);
+  const def = readDef(node);
+  if (def === void 0) return;
+  const checks = getChecks(node);
+  if (checks.some(isAsyncCheck)) capabilities.asyncRefine = true;
+  if (checks.length > 0 && CONTAINER_SLOTS.some((key) => def[key] !== void 0)) {
+    capabilities.containerOrRootRefine = true;
+  }
+  if (typeof def.transform === "function" && def.transform.constructor.name === "AsyncFunction") {
+    capabilities.asyncTransform = true;
+  }
+  if (kindOf(node) === "discriminated-union") capabilities.discriminatedUnion = true;
+  if (isCoercePrimitive(node) || isPreprocessNode(node)) capabilities.preprocessOrCoerce = true;
+  for (const key of DESCEND_SINGLE) walkCapabilities(def[key], capabilities, visited);
+  for (const key of DESCEND_RECORD) {
+    for (const sub of Object.values(def[key] ?? {})) walkCapabilities(sub, capabilities, visited);
+  }
+  for (const key of DESCEND_LIST) {
+    for (const sub of def[key] ?? []) walkCapabilities(sub, capabilities, visited);
+  }
+  if (typeof def.getter === "function") {
+    try {
+      walkCapabilities(def.getter(), capabilities, visited);
+    } catch {
+    }
+  }
 }
 function isAsyncCheck(check) {
   if (typeof check !== "object" || check === null) return false;
@@ -335,10 +303,10 @@ function zodIssuesToValidationErrors(issues) {
     }
     return {
       message: issue.message,
-      // 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: issue.path.map((seg) => typeof seg === "number" ? seg : String(seg)),
       code
     };
@@ -354,10 +322,7 @@ const V4_INTROSPECTOR = {
   getLiteralValues,
   isPreprocessNode,
   isCoercePrimitive,
-  containsAsyncRefine,
-  containsAsyncTransform,
-  containsDiscriminatedUnion,
-  hasContainerOrRootRefine,
+  capabilitiesOf,
   // Walker accessors (D2 / D3 / D5).
   getArrayElement: (schema) => {
     if (kindOf(schema) !== "array") return void 0;
@@ -384,7 +349,7 @@ const V4_INTROSPECTOR = {
 };
 
 function slimPrimitivesOf(schema, maxRecursionDepth) {
-  return new Set(slimPrimitivesWalk(schema, V4_INTROSPECTOR, maxRecursionDepth));
+  return slimPrimitivesWalk(schema, V4_INTROSPECTOR, maxRecursionDepth);
 }
 
 function deriveDefault(schema, useDefault, maxRecursionDepth) {
@@ -533,13 +498,14 @@ const sharedV4Schemas = createSharedSchemaStore();
 function buildV4Services() {
   return {
     getNestedSchemasAtPath: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
-    // v4 doesn't pre-strip for the slim-mode walk — its path walker
-    // already peels every transparent wrapper inline, so the slim and
-    // unstripped walks coincide.
+    // No pre-strip for the slim-mode walk: the path walker peels every
+    // transparent wrapper inline, so the slim and unstripped walks
+    // coincide.
     getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
     slimPrimitivesOf: (schema, maxRecursionDepth) => slimPrimitivesOf(schema, maxRecursionDepth),
     deriveDefault: (schema, useDefault, maxRecursionDepth) => deriveDefault(schema, useDefault, maxRecursionDepth),
     runGetDefaults: (schema, config, maxRecursionDepth) => runGetDefaultsV4(schema, config, maxRecursionDepth),
+    validateSync: (schema, data) => validateSyncV4(schema, data),
     unwrapStructuralWrappers: (schema) => unwrapStructuralWrappers(schema),
     unwrapToDiscriminatedUnion: (schema) => unwrapToDiscriminatedUnion(schema),
     peelAllWrappers: (schema) => peelAllWrappers(schema),
@@ -558,37 +524,35 @@ function buildV4Services() {
   };
 }
 function runGetDefaultsV4(rootSchema, config, maxRecursionDepth) {
-  const { data } = getDefaultValuesFromZodSchema({
+  return getDefaultValuesFromZodSchema({
     schema: rootSchema,
     useDefaultSchemaValues: config.useDefaultSchemaValues,
     constraints: config.constraints,
     maxRecursionDepth
-  });
-  if (containsAsyncTransform(rootSchema) || containsAsyncRefine(rootSchema)) {
-    return { data, errors: void 0, success: true };
-  }
+  }).data;
+}
+const verdictRan = /* @__PURE__ */ new WeakMap();
+function validateSyncV4(rootSchema, data) {
+  const { asyncRefine, asyncTransform } = capabilitiesOf(rootSchema);
+  if (asyncRefine || asyncTransform) return [];
   try {
-    const parseResult = rootSchema.safeParse(data);
-    if (parseResult.success) {
-      return { data, errors: void 0, success: true };
-    }
-    return {
-      data,
-      errors: zodIssuesToValidationErrors(parseResult.error.issues),
-      success: false
-    };
+    const jitless = !verdictRan.has(rootSchema);
+    if (jitless) verdictRan.set(rootSchema, true);
+    const parseResult = rootSchema.safeParse(data, { jitless });
+    return parseResult.success ? [] : zodIssuesToValidationErrors(parseResult.error.issues);
   } catch {
-    return { data, errors: void 0, success: true };
+    return [];
   }
 }
 function buildSubSchemaStubV4(schema, maxRecursionDepth) {
   return {
-    needsAsyncValidation: () => containsAsyncRefine(schema),
-    getDefaultValues: () => ({
-      data: deriveDefault(schema, true, maxRecursionDepth),
-      errors: void 0,
-      success: true
-    }),
+    // Async work of either kind, as the root's `needsAsyncValidation`
+    // counts it: the field's `valid` waits for the first async pass.
+    needsAsyncValidation: () => {
+      const { asyncRefine, asyncTransform } = scanCapabilities(schema);
+      return asyncRefine || asyncTransform;
+    },
+    getDefaultValues: () => deriveDefault(schema, true, maxRecursionDepth),
     getSchemasAtPath: () => [],
     validateAtPath: async (data) => {
       const result = await schema.safeParseAsync(data);

package/dist/shared/{attaform.WiGdIqgx.mjs → attaform.C4shmwyJ.mjs}

@@ -168,8 +168,8 @@ function renderAttaformState(app) {
         // The wire shape stays two per-source arrays; the tagged store
         // splits at the boundary and the client replays each side into
         // its cell half.
-        schemaErrors: [...state.errorCells.entries()].filter(([, cell]) => cell.schema.length > 0).map(([key2, cell]) => [key2, cell.schema]),
-        userErrors: [...state.errorCells.entries()].filter(([, cell]) => cell.user.length > 0).map(([key2, cell]) => [key2, cell.user]),
+        schemaErrors: [...state.errorCells().entries()].filter(([, cell]) => cell.schema.length > 0).map(([key2, cell]) => [key2, cell.schema]),
+        userErrors: [...state.errorCells().entries()].filter(([, cell]) => cell.user.length > 0).map(([key2, cell]) => [key2, cell.user]),
         fields: Array.from(state.fields.entries()),
         ...transientList.length > 0 ? { blankPaths: transientList } : {}
       }