attaform 0.24.0 → 0.24.2

package/dist/shared/attaform.WvcckZMD.mjs

@@ -0,0 +1,21 @@
+import { isRef } from 'vue';
+
+const V_REGISTER_MARKER = Symbol.for("attaform:v-register-directive");
+const REGISTER_OWNER_MARKER = Symbol.for("attaform:register-owner-marker");
+const SSR_COMPONENT_HOST_MODIFIER = "attaformComponentHost";
+function isRegisterValue(val) {
+  if (typeof val !== "object" || val === null) return false;
+  if (!("innerRef" in val)) return false;
+  if (!isRef(val.innerRef)) return false;
+  if (!("registerElement" in val)) return false;
+  if (typeof val.registerElement !== "function") return false;
+  if (!("setValueWithInternalPath" in val)) return false;
+  if (typeof val.setValueWithInternalPath !== "function") return false;
+  return true;
+}
+function isTransforming(value) {
+  return isRegisterValue(value) && value.transforming;
+}
+
+export { REGISTER_OWNER_MARKER as R, SSR_COMPONENT_HOST_MODIFIER as S, V_REGISTER_MARKER as V, isTransforming as a, isRegisterValue as i };
+//# sourceMappingURL=attaform.WvcckZMD.mjs.map

package/dist/shared/attaform.WvcckZMD.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"attaform.WvcckZMD.mjs","sources":["../../src/runtime/core/register-protocol.ts"],"sourcesContent":["import { isRef } from 'vue'\nimport type { InternalRegisterValue, RegisterValue } from '../types/types-api'\n\n// Shared register-protocol primitives: the markers and value guards that\n// the v-register directive, its file / lifecycle satellites, and\n// useRegister all build on. They live in this leaf (depending only on vue\n// and the types module) so those modules don't import directive.ts back,\n// which would form an import cycle.\n\n/**\n * Marker installed on the v-register directive object so consumers\n * (notably `useRegister`) can identify it in a child vnode's\n * directive list even when the consumer's bundler hasn't installed\n * attaform's compile-time transforms. `Symbol.for(...)` round-trips\n * across duplicate bundle copies: `attaform` and `attaform/zod` can\n * land on different `vRegister` references in the playground or\n * under pnpm-hoist edge cases, but both carry the same marker.\n */\nexport const V_REGISTER_MARKER: unique symbol = Symbol.for('attaform:v-register-directive')\n\n/**\n * Marker on the rendered root DOM element. Set by `useRegister`'s\n * `onMounted` hook; read by the directive's deferred warn check to\n * skip the \"is a no-op\" warn for components that handle binding via\n * an inner v-register.\n *\n * `Symbol.for(...)` so the marker round-trips across duplicate copies\n * of attaform — see `assignKey` in core/directive.ts for the same\n * reasoning. `useRegister` and the directive are typically loaded\n * from the same module copy, but a consumer importing from\n * `attaform/zod` (Vite-optimized bundle) and the Nuxt\n * plugin's relative-path import (live ESM) can land on different\n * copies; a global symbol means the marker check still works.\n */\nexport const REGISTER_OWNER_MARKER: unique symbol = Symbol.for('attaform:register-owner-marker')\n\n/**\n * Directive modifier the `componentBridgeTransform` stamps onto a\n * `v-register` that lands on a component host (or kebab custom element).\n * It is the compile-time -> runtime signal the directive's `getSSRProps`\n * reads under compiled SSR, where Vue passes a `null` vnode and the host\n * is otherwise indistinguishable from a native control. autoAria then\n * suppresses its attrs on the host root (the inner control the component\n * re-binds via useRegister carries them). Namespaced to avoid collision\n * with any author-written modifier. (#404)\n */\nexport const SSR_COMPONENT_HOST_MODIFIER = 'attaformComponentHost'\n\n/**\n * Type guard for a `RegisterValue`. Returns `true` when `val` looks\n * like the object returned from `form.register(path)`.\n *\n * ```ts\n * if (isRegisterValue(slotValue)) {\n *   // slotValue.innerRef is now a Ref<unknown>\n * }\n * ```\n *\n * Useful when building wrapper components that accept either a\n * `RegisterValue` or a plain ref via the same prop.\n */\nexport function isRegisterValue<Value = unknown>(val: unknown): val is RegisterValue<Value> {\n  if (typeof val !== 'object' || val === null) return false\n  if (!('innerRef' in val)) return false\n  if (!isRef(val.innerRef)) return false\n  if (!('registerElement' in val)) return false\n  if (typeof val.registerElement !== 'function') return false\n  if (!('setValueWithInternalPath' in val)) return false\n  if (typeof val.setValueWithInternalPath !== 'function') return false\n  return true\n}\n\n/**\n * `true` while a deferred async transform is in flight at this path.\n * `beginTransform` flips it synchronously inside the assigner, so a\n * listener's post-write force-sync block reads it (right after the\n * assigner returns) to skip snapping the DOM back to stale storage —\n * the resolved value is painted in by the orchestrator's `syncDom`\n * once the run lands.\n */\nexport function isTransforming(value: unknown): boolean {\n  return isRegisterValue(value) && (value as InternalRegisterValue).transforming\n}\n"],"names":[],"mappings":";;AAkBO,MAAM,iBAAA,GAAmC,MAAA,CAAO,GAAA,CAAI,+BAA+B;AAgBnF,MAAM,qBAAA,GAAuC,MAAA,CAAO,GAAA,CAAI,gCAAgC;AAYxF,MAAM,2BAAA,GAA8B;AAepC,SAAS,gBAAiC,GAAA,EAA2C;AAC1F,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,MAAM,OAAO,KAAA;AACpD,EAAA,IAAI,EAAE,UAAA,IAAc,GAAA,CAAA,EAAM,OAAO,KAAA;AACjC,EAAA,IAAI,CAAC,KAAA,CAAM,GAAA,CAAI,QAAQ,GAAG,OAAO,KAAA;AACjC,EAAA,IAAI,EAAE,iBAAA,IAAqB,GAAA,CAAA,EAAM,OAAO,KAAA;AACxC,EAAA,IAAI,OAAO,GAAA,CAAI,eAAA,KAAoB,UAAA,EAAY,OAAO,KAAA;AACtD,EAAA,IAAI,EAAE,0BAAA,IAA8B,GAAA,CAAA,EAAM,OAAO,KAAA;AACjD,EAAA,IAAI,OAAO,GAAA,CAAI,wBAAA,KAA6B,UAAA,EAAY,OAAO,KAAA;AAC/D,EAAA,OAAO,IAAA;AACT;AAUO,SAAS,eAAe,KAAA,EAAyB;AACtD,EAAA,OAAO,eAAA,CAAgB,KAAK,CAAA,IAAM,KAAA,CAAgC,YAAA;AACpE;;;;"}

package/dist/shared/{attaform.DiWNbKWa.d.mts → attaform.yqcYwt0d.d.ts}

@@ -1,4 +1,4 @@
-import { F as FormKey, W as PathKey, m as DisplayCtx, d as GetDisplayState, n as DisplayMachine, V as Path, aa as SlimPrimitiveKind, C as CoercionEntry, g as CoercionRegistry, G as GenericForm, ag as ValidationError, a as AbstractSchema, ak as WriteMeta, j as DeepPartial, al as WriteShape, as as TransformAbortHolder, ae as ValidateOn, A as AttaformDefaults, b as UseFormReturnType, c as RegisterValue } from './attaform.GJbSmwLB.mjs';
+import { F as FormKey, W as PathKey, m as DisplayCtx, d as GetDisplayState, n as DisplayMachine, V as Path, aa as SlimPrimitiveKind, C as CoercionEntry, g as CoercionRegistry, G as GenericForm, ag as ValidationError, a as AbstractSchema, ak as WriteMeta, j as DeepPartial, al as WriteShape, at as TransformAbortHolder, ae as ValidateOn, A as AttaformDefaults, b as UseFormReturnType, c as RegisterValue } from './attaform.DUc6cetN.js';
 import { Ref, ComputedRef, App, InjectionKey } from 'vue';
 
 /**
@@ -209,9 +209,11 @@ type WizardSubmitContext = {
 type WizardOnSubmit = (ctx: WizardSubmitContext) => void | Promise<void>;
 /**
  * Optional `onError` callback registered via `wizard.handleSubmit`.
- * Receives the aggregate error list — entries originate from per-form
- * validation and activation failures (`atta:activation-failed`). Sync
- * or async; the returned promise gates `wizard.submitting`.
+ * Receives the aggregate error list. Entries originate from per-form
+ * validation, activation failures (`atta:activation-failed`), and a
+ * submit callback that left errors on a processed step (the
+ * `setErrors(...); return` server-rejection path). Sync or async; the
+ * returned promise gates `wizard.submitting`.
  */
 type WizardOnError = (errors: readonly WizardAggregateError[]) => void | Promise<void>;
 /**
@@ -402,25 +404,32 @@ type WizardForms<S> = FormsRecordOf<S> & Readonly<Record<FormKey, AnyForm>>;
  *                    Forward-looking; reactive to current form
  *                    validity. Gates "Finish button enable" style UI.
  *  - `done`        — monotonic latch: flips `true` the first time a
- *                    final-step `handleSubmit` resolves without
- *                    throwing, and stays `true` through subsequent
- *                    edits or invalidations. Only `reset()` flips it
- *                    back. Gates "show success card" style UI that
- *                    should reflect submission history rather than
- *                    current validity.
+ *                    final-step `handleSubmit` resolves without throwing
+ *                    AND leaves no errors set on any step, and stays
+ *                    `true` through subsequent edits or invalidations. A
+ *                    callback that calls `setErrors` and returns (the
+ *                    documented server-rejection path) is a failed submit,
+ *                    so it does not flip `done`. Only `reset()` flips it
+ *                    back. Gates "show success card" style UI that should
+ *                    reflect submission history rather than current
+ *                    validity.
  *  - `submitting`  — `true` while a `wizard.handleSubmit` call is in
  *                    flight. Global re-entrance guard: every
  *                    navigation method also refuses while this is on.
  *  - `submissionAttempts` — count of `wizard.handleSubmit` invocations
  *                    (success or failure). Always bumps, including on
  *                    noop-form steps.
- *  - `submitError` — the error thrown by the most recent
+ *  - `submitError` — the error THROWN by the most recent
  *                    `wizard.handleSubmit` callback (or its `onError`),
  *                    coerced to a real `Error`. Mirrors
- *                    `form.meta.submitError`: cleared at submit entry and
- *                    by `reset()`, parked here rather than re-thrown, so
- *                    the handler resolves and never manufactures a
- *                    `window` unhandledrejection. `null` on success.
+ *                    `form.meta.submitError`: this is the unexpected-throw
+ *                    channel, so an expected rejection handled via
+ *                    `setErrors` (no throw) surfaces through the error
+ *                    surface and `onError` instead, leaving this `null`.
+ *                    Cleared at submit entry and by `reset()`, parked here
+ *                    rather than re-thrown, so the handler resolves and
+ *                    never manufactures a `window` unhandledrejection.
+ *                    `null` on success.
  *  - `visited`     — append-only breadcrumb of navigated step keys.
  *                    `back()` does not pop; the trail is the audit
  *                    log, not the back-stack.
@@ -1091,6 +1100,15 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * no longer see the shape change.
      */
     hasStructuralChangeUnder(path: Path): boolean;
+    /**
+     * Whether a baseline-present container under `path` was replaced wholesale by
+     * a non-container (e.g. `setValue('profile', undefined)`) and is still absent.
+     * The other half of removal-driven `dirty`: such a subtree's leaves vanish
+     * from the live value, so neither the present-leaf walk nor the array tracker
+     * can see the loss. Self-filters by current liveness, so a refilled path stops
+     * counting.
+     */
+    hasRemovedSubtreeUnder(path: Path): boolean;
     getFieldRecord(path: Path): FieldRecord | undefined;
     getOriginalAtPath(path: Path): unknown;
     /**

package/dist/transforms.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const vRegisterPreambleTransform = require('./shared/attaform.CR6wGvNu.cjs');
+const vRegisterPreambleTransform = require('./shared/attaform.DK6_Ctv7.cjs');
 
 
 

package/dist/transforms.d.cts

@@ -10,7 +10,10 @@ import { NodeTransform } from '@vue/compiler-core';
  *   - `<MyComponent v-register>` and kebab-case custom-element hosts
  *     — injects a `:registerValue` bridge prop so `useRegister` inside
  *     the child sees the parent's RegisterValue (the binding the audit
- *     called out as the transform's "fires on every component" path).
+ *     called out as the transform's "fires on every component" path),
+ *     and marks any parent-authored slotted `<option>`s with `:selected`
+ *     the same way the native path does, so a `<select>` wrapped in a
+ *     styled component keeps its SSR-selected option (#394).
  *
  * Wired automatically by `attaform/vite` and `attaform/nuxt`. Use
  * directly only when integrating with a custom bundler.

package/dist/transforms.d.mts

@@ -10,7 +10,10 @@ import { NodeTransform } from '@vue/compiler-core';
  *   - `<MyComponent v-register>` and kebab-case custom-element hosts
  *     — injects a `:registerValue` bridge prop so `useRegister` inside
  *     the child sees the parent's RegisterValue (the binding the audit
- *     called out as the transform's "fires on every component" path).
+ *     called out as the transform's "fires on every component" path),
+ *     and marks any parent-authored slotted `<option>`s with `:selected`
+ *     the same way the native path does, so a `<select>` wrapped in a
+ *     styled component keeps its SSR-selected option (#394).
  *
  * Wired automatically by `attaform/vite` and `attaform/nuxt`. Use
  * directly only when integrating with a custom bundler.

package/dist/transforms.d.ts

@@ -10,7 +10,10 @@ import { NodeTransform } from '@vue/compiler-core';
  *   - `<MyComponent v-register>` and kebab-case custom-element hosts
  *     — injects a `:registerValue` bridge prop so `useRegister` inside
  *     the child sees the parent's RegisterValue (the binding the audit
- *     called out as the transform's "fires on every component" path).
+ *     called out as the transform's "fires on every component" path),
+ *     and marks any parent-authored slotted `<option>`s with `:selected`
+ *     the same way the native path does, so a `<select>` wrapped in a
+ *     styled component keeps its SSR-selected option (#394).
  *
  * Wired automatically by `attaform/vite` and `attaform/nuxt`. Use
  * directly only when integrating with a custom bundler.

package/dist/transforms.mjs

@@ -1,2 +1,2 @@
-export { c as componentBridgeTransform, i as inputTextAreaNodeTransform, v as vRegisterHintTransform, a as vRegisterPreambleTransform } from './shared/attaform.BFWb6hDk.mjs';
+export { c as componentBridgeTransform, i as inputTextAreaNodeTransform, v as vRegisterHintTransform, a as vRegisterPreambleTransform } from './shared/attaform.DwCtxauq.mjs';
 //# sourceMappingURL=transforms.mjs.map

package/dist/vite.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 const detectZodMajor = require('./shared/attaform.LEWUFqUw.cjs');
-const vRegisterPreambleTransform = require('./shared/attaform.CR6wGvNu.cjs');
+const vRegisterPreambleTransform = require('./shared/attaform.DK6_Ctv7.cjs');
 const compilerSfc = require('@vue/compiler-sfc');
 const compilerCore = require('@vue/compiler-core');
 

package/dist/vite.mjs

@@ -1,5 +1,5 @@
 import { r as resolveZodAliasTarget, Z as ZOD_UNIFIED_SPECIFIER } from './shared/attaform.sHkHv_98.mjs';
-import { a as vRegisterPreambleTransform, c as componentBridgeTransform, i as inputTextAreaNodeTransform, v as vRegisterHintTransform } from './shared/attaform.BFWb6hDk.mjs';
+import { a as vRegisterPreambleTransform, c as componentBridgeTransform, i as inputTextAreaNodeTransform, v as vRegisterHintTransform } from './shared/attaform.DwCtxauq.mjs';
 import { parse, babelParse } from '@vue/compiler-sfc';
 import { NodeTypes } from '@vue/compiler-core';
 

package/dist/zod-v3.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-const useForm = require('./shared/attaform.Z1qTwOYE.cjs');
-const injectWizard = require('./shared/attaform.C42wL7EJ.cjs');
+const useForm = require('./shared/attaform.B57G7ePY.cjs');
+const injectWizard = require('./shared/attaform.Bos7wVZw.cjs');
 
 
 

package/dist/zod-v3.d.cts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { G as GenericForm, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, D as DefaultValuesInput, b as UseFormReturnType, af as ValidateOnConfig, ar as SchemaFactoryOptions, q as FieldMetaPayload } from './shared/attaform.GJbSmwLB.cjs';
-export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.GJbSmwLB.cjs';
+import { G as GenericForm, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, ar as AcceptableDefaults, b as UseFormReturnType, af as ValidateOnConfig, as as SchemaFactoryOptions, q as FieldMetaPayload } from './shared/attaform.DUc6cetN.cjs';
+export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.DUc6cetN.cjs';
 import { S as SupportedRootSchema, U as UnwrapZodRoot, a as StorageShape } from './shared/attaform.DdjDqTah.cjs';
-export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.DdUYEhkV.cjs';
+export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.DHjRN5JP.cjs';
 import 'vue';
 
 /**
@@ -32,7 +32,9 @@ type ReadOf<Schema extends SupportedRootSchema> = StorageShape<UnwrapZodRoot<Sch
  * directly — it wraps the adapter automatically. For Zod v4, import
  * from `attaform/zod` instead.
  */
-declare function useForm<Form extends GenericForm, GetValueFormType extends GenericForm = Form, K extends FormKey = FormKey>(configuration: UseFormConfiguration<Form, GetValueFormType, AbstractSchema<Form, GetValueFormType>, DefaultValuesInput<Form>, K>): UseFormReturnType<Form, GetValueFormType, Form, K>;
+declare function useForm<Form extends GenericForm, GetValueFormType extends GenericForm = Form, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<Form, GetValueFormType, AbstractSchema<Form, GetValueFormType>, never, K>, 'defaultValues'> & {
+    defaultValues?: AcceptableDefaults<Form, Form>;
+}): UseFormReturnType<Form, GetValueFormType, Form, K>;
 /**
  * Create a form bound to a Zod v3 `ZodObject` schema.
  *
@@ -57,8 +59,9 @@ declare function useForm<Form extends GenericForm, GetValueFormType extends Gene
  *
  * For Zod v4, import from `attaform/zod` instead.
  */
-declare function useForm<Schema extends SupportedRootSchema, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<FormOf<Schema>, OutOf<Schema>, AbstractSchema<FormOf<Schema>, OutOf<Schema>>, DefaultValuesInput<FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
+declare function useForm<Schema extends SupportedRootSchema, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<FormOf<Schema>, OutOf<Schema>, AbstractSchema<FormOf<Schema>, OutOf<Schema>>, never, K>, 'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'> & {
     schema: Schema;
+    defaultValues?: AcceptableDefaults<FormOf<Schema>, z.input<Schema>>;
 } & ValidateOnConfig): UseFormReturnType<FormOf<Schema>, OutOf<Schema>, ReadOf<Schema>, K>;
 
 /**

package/dist/zod-v3.d.mts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { G as GenericForm, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, D as DefaultValuesInput, b as UseFormReturnType, af as ValidateOnConfig, ar as SchemaFactoryOptions, q as FieldMetaPayload } from './shared/attaform.GJbSmwLB.mjs';
-export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.GJbSmwLB.mjs';
+import { G as GenericForm, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, ar as AcceptableDefaults, b as UseFormReturnType, af as ValidateOnConfig, as as SchemaFactoryOptions, q as FieldMetaPayload } from './shared/attaform.DUc6cetN.mjs';
+export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.DUc6cetN.mjs';
 import { S as SupportedRootSchema, U as UnwrapZodRoot, a as StorageShape } from './shared/attaform.DdjDqTah.mjs';
-export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.DiWNbKWa.mjs';
+export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.0zueP54D.mjs';
 import 'vue';
 
 /**
@@ -32,7 +32,9 @@ type ReadOf<Schema extends SupportedRootSchema> = StorageShape<UnwrapZodRoot<Sch
  * directly — it wraps the adapter automatically. For Zod v4, import
  * from `attaform/zod` instead.
  */
-declare function useForm<Form extends GenericForm, GetValueFormType extends GenericForm = Form, K extends FormKey = FormKey>(configuration: UseFormConfiguration<Form, GetValueFormType, AbstractSchema<Form, GetValueFormType>, DefaultValuesInput<Form>, K>): UseFormReturnType<Form, GetValueFormType, Form, K>;
+declare function useForm<Form extends GenericForm, GetValueFormType extends GenericForm = Form, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<Form, GetValueFormType, AbstractSchema<Form, GetValueFormType>, never, K>, 'defaultValues'> & {
+    defaultValues?: AcceptableDefaults<Form, Form>;
+}): UseFormReturnType<Form, GetValueFormType, Form, K>;
 /**
  * Create a form bound to a Zod v3 `ZodObject` schema.
  *
@@ -57,8 +59,9 @@ declare function useForm<Form extends GenericForm, GetValueFormType extends Gene
  *
  * For Zod v4, import from `attaform/zod` instead.
  */
-declare function useForm<Schema extends SupportedRootSchema, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<FormOf<Schema>, OutOf<Schema>, AbstractSchema<FormOf<Schema>, OutOf<Schema>>, DefaultValuesInput<FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
+declare function useForm<Schema extends SupportedRootSchema, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<FormOf<Schema>, OutOf<Schema>, AbstractSchema<FormOf<Schema>, OutOf<Schema>>, never, K>, 'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'> & {
     schema: Schema;
+    defaultValues?: AcceptableDefaults<FormOf<Schema>, z.input<Schema>>;
 } & ValidateOnConfig): UseFormReturnType<FormOf<Schema>, OutOf<Schema>, ReadOf<Schema>, K>;
 
 /**

package/dist/zod-v3.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { G as GenericForm, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, D as DefaultValuesInput, b as UseFormReturnType, af as ValidateOnConfig, ar as SchemaFactoryOptions, q as FieldMetaPayload } from './shared/attaform.GJbSmwLB.js';
-export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.GJbSmwLB.js';
+import { G as GenericForm, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, ar as AcceptableDefaults, b as UseFormReturnType, af as ValidateOnConfig, as as SchemaFactoryOptions, q as FieldMetaPayload } from './shared/attaform.DUc6cetN.js';
+export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.DUc6cetN.js';
 import { S as SupportedRootSchema, U as UnwrapZodRoot, a as StorageShape } from './shared/attaform.DdjDqTah.js';
-export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.C6eE50re.js';
+export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.yqcYwt0d.js';
 import 'vue';
 
 /**
@@ -32,7 +32,9 @@ type ReadOf<Schema extends SupportedRootSchema> = StorageShape<UnwrapZodRoot<Sch
  * directly — it wraps the adapter automatically. For Zod v4, import
  * from `attaform/zod` instead.
  */
-declare function useForm<Form extends GenericForm, GetValueFormType extends GenericForm = Form, K extends FormKey = FormKey>(configuration: UseFormConfiguration<Form, GetValueFormType, AbstractSchema<Form, GetValueFormType>, DefaultValuesInput<Form>, K>): UseFormReturnType<Form, GetValueFormType, Form, K>;
+declare function useForm<Form extends GenericForm, GetValueFormType extends GenericForm = Form, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<Form, GetValueFormType, AbstractSchema<Form, GetValueFormType>, never, K>, 'defaultValues'> & {
+    defaultValues?: AcceptableDefaults<Form, Form>;
+}): UseFormReturnType<Form, GetValueFormType, Form, K>;
 /**
  * Create a form bound to a Zod v3 `ZodObject` schema.
  *
@@ -57,8 +59,9 @@ declare function useForm<Form extends GenericForm, GetValueFormType extends Gene
  *
  * For Zod v4, import from `attaform/zod` instead.
  */
-declare function useForm<Schema extends SupportedRootSchema, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<FormOf<Schema>, OutOf<Schema>, AbstractSchema<FormOf<Schema>, OutOf<Schema>>, DefaultValuesInput<FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
+declare function useForm<Schema extends SupportedRootSchema, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<FormOf<Schema>, OutOf<Schema>, AbstractSchema<FormOf<Schema>, OutOf<Schema>>, never, K>, 'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'> & {
     schema: Schema;
+    defaultValues?: AcceptableDefaults<FormOf<Schema>, z.input<Schema>>;
 } & ValidateOnConfig): UseFormReturnType<FormOf<Schema>, OutOf<Schema>, ReadOf<Schema>, K>;
 
 /**

package/dist/zod-v3.mjs

@@ -1,3 +1,3 @@
-export { f as fieldMeta, i as isZodSchemaType, u as useForm, w as withMeta, z as zodAdapter } from './shared/attaform.BJ_W7q3U.mjs';
-export { A as AttaformErrorCode, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, c as useRegister, d as useWizard } from './shared/attaform.CuBdtfbe.mjs';
+export { f as fieldMeta, i as isZodSchemaType, u as useForm, w as withMeta, z as zodAdapter } from './shared/attaform.B_-nZHtM.mjs';
+export { A as AttaformErrorCode, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, c as useRegister, d as useWizard } from './shared/attaform.BI7M3wK8.mjs';
 //# sourceMappingURL=zod-v3.mjs.map

package/dist/zod-v4.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-const index = require('./shared/attaform.BnUXV01g.cjs');
-const injectWizard = require('./shared/attaform.C42wL7EJ.cjs');
+const index = require('./shared/attaform.D-gYGj5z.cjs');
+const injectWizard = require('./shared/attaform.Bos7wVZw.cjs');
 
 
 

package/dist/zod-v4.d.cts

@@ -1,8 +1,8 @@
-import { S as SupportedRootSchema } from './shared/attaform.K-3glmiT.cjs';
-export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.K-3glmiT.cjs';
-export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.DdUYEhkV.cjs';
-import { F as FormKey, ar as SchemaFactoryOptions, a as AbstractSchema, q as FieldMetaPayload } from './shared/attaform.GJbSmwLB.cjs';
-export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.GJbSmwLB.cjs';
+import { S as SupportedRootSchema } from './shared/attaform.Bx6pgrIy.cjs';
+export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.Bx6pgrIy.cjs';
+export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.DHjRN5JP.cjs';
+import { F as FormKey, as as SchemaFactoryOptions, a as AbstractSchema, q as FieldMetaPayload } from './shared/attaform.DUc6cetN.cjs';
+export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.DUc6cetN.cjs';
 import { z } from 'zod';
 import { A as AttaformError } from './shared/attaform.CO0e7YVY.cjs';
 import 'vue';

package/dist/zod-v4.d.mts

@@ -1,8 +1,8 @@
-import { S as SupportedRootSchema } from './shared/attaform.BNmkKz0q.mjs';
-export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.BNmkKz0q.mjs';
-export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.DiWNbKWa.mjs';
-import { F as FormKey, ar as SchemaFactoryOptions, a as AbstractSchema, q as FieldMetaPayload } from './shared/attaform.GJbSmwLB.mjs';
-export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.GJbSmwLB.mjs';
+import { S as SupportedRootSchema } from './shared/attaform.DvqdxvNU.mjs';
+export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.DvqdxvNU.mjs';
+export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.0zueP54D.mjs';
+import { F as FormKey, as as SchemaFactoryOptions, a as AbstractSchema, q as FieldMetaPayload } from './shared/attaform.DUc6cetN.mjs';
+export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.DUc6cetN.mjs';
 import { z } from 'zod';
 import { A as AttaformError } from './shared/attaform.CO0e7YVY.mjs';
 import 'vue';

package/dist/zod-v4.d.ts

@@ -1,8 +1,8 @@
-import { S as SupportedRootSchema } from './shared/attaform.CwFZGv5-.js';
-export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.CwFZGv5-.js';
-export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.C6eE50re.js';
-import { F as FormKey, ar as SchemaFactoryOptions, a as AbstractSchema, q as FieldMetaPayload } from './shared/attaform.GJbSmwLB.js';
-export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.GJbSmwLB.js';
+import { S as SupportedRootSchema } from './shared/attaform.BjiHiYAZ.js';
+export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.BjiHiYAZ.js';
+export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.yqcYwt0d.js';
+import { F as FormKey, as as SchemaFactoryOptions, a as AbstractSchema, q as FieldMetaPayload } from './shared/attaform.DUc6cetN.js';
+export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.DUc6cetN.js';
 import { z } from 'zod';
 import { A as AttaformError } from './shared/attaform.CO0e7YVY.js';
 import 'vue';

package/dist/zod-v4.mjs

@@ -1,3 +1,3 @@
-export { U as UnsupportedSchemaError, a as assertZodVersion, f as fieldMeta, k as kindOf, u as useForm, w as withMeta, z as zodAdapter } from './shared/attaform.C-dAB90u.mjs';
-export { A as AttaformErrorCode, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, c as useRegister, d as useWizard } from './shared/attaform.CuBdtfbe.mjs';
+export { U as UnsupportedSchemaError, a as assertZodVersion, f as fieldMeta, k as kindOf, u as useForm, w as withMeta, z as zodAdapter } from './shared/attaform.K1MbxmIu.mjs';
+export { A as AttaformErrorCode, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, c as useRegister, d as useWizard } from './shared/attaform.BI7M3wK8.mjs';
 //# sourceMappingURL=zod-v4.mjs.map

package/dist/zod.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-const paths = require('./shared/attaform.DwkU0oY9.cjs');
-const useForm$1 = require('./shared/attaform.Z1qTwOYE.cjs');
-const index = require('./shared/attaform.BnUXV01g.cjs');
-const walkFieldMeta = require('./shared/attaform.BV_HyaMO.cjs');
-const injectWizard = require('./shared/attaform.C42wL7EJ.cjs');
+const paths = require('./shared/attaform.B7UdTs_o.cjs');
+const useForm$1 = require('./shared/attaform.B57G7ePY.cjs');
+const index = require('./shared/attaform.D-gYGj5z.cjs');
+const walkFieldMeta = require('./shared/attaform.DdfLrIgM.cjs');
+const injectWizard = require('./shared/attaform.Bos7wVZw.cjs');
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;

package/dist/zod.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"zod.cjs","sources":["../src/runtime/core/zod-shape.ts","../src/runtime/adapters/unified/use-form.ts","../src/runtime/adapters/unified/field-meta.ts"],"sourcesContent":["/**\n * Shape detectors for Zod schemas. Used by the unified `attaform/zod`\n * entry's runtime dispatch (`runtime/adapters/unified/use-form.ts`)\n * to route to the v3 or v4 adapter based on the schema's runtime\n * shape. Mirrors the discrimination already used by the v4\n * introspection helper (`adapters/zod-v4/introspect.ts`'s\n * `assertZodVersion`, which reads `def.type`) and the v3 wrapper's\n * legitimate-input branch (`composables/use-form.ts`'s `isZodType`,\n * which reads `_def`).\n *\n * Why this discriminator and not `_zod` / `_def`:\n * - Zod v4 retained `_def` for backward compat — reading `_def` alone\n *   misclassifies v4 schemas as v3.\n * - Zod v4's stable shape is `def.type: string` (lowercase tag like\n *   `'object'`); Zod v3's is `_def.typeName: string` (capitalised tag\n *   like `'ZodObject'`). Both are checked structurally so consumers\n *   who alias one Zod major to a non-standard import path still work.\n */\n\ninterface ZodV4Shape {\n  def: { type: unknown }\n}\n\ninterface ZodV3Shape {\n  _def: { typeName: unknown }\n}\n\n/**\n * Returns true when `value` looks like a Zod schema of either major\n * version. Convenience wrapper around the v3 / v4 detectors.\n */\nexport function isZodSchemaShape(value: unknown): boolean {\n  return isZodV4SchemaShape(value) || isZodV3SchemaShape(value)\n}\n\n/**\n * Returns true when `value` looks like a Zod v4 schema (has\n * `def.type: string`). Used by the unified entry's runtime-dispatch\n * to route to the v4 adapter.\n */\nexport function isZodV4SchemaShape(value: unknown): value is ZodV4Shape {\n  if (typeof value !== 'object' || value === null) return false\n  const def = (value as { def?: unknown }).def\n  if (typeof def !== 'object' || def === null) return false\n  return typeof (def as { type?: unknown }).type === 'string'\n}\n\n/**\n * Returns true when `value` looks like a Zod v3 schema (has\n * `_def.typeName: string`). Kept distinct from `isZodV4SchemaShape`\n * because some v4 schemas also expose `_def` for backward compat —\n * the v4 detector wins first in `isZodSchemaShape`.\n */\nexport function isZodV3SchemaShape(value: unknown): value is ZodV3Shape {\n  if (typeof value !== 'object' || value === null) return false\n  const def = (value as { _def?: unknown })._def\n  if (typeof def !== 'object' || def === null) return false\n  return typeof (def as { typeName?: unknown }).typeName === 'string'\n}\n","/**\n * Unified `useForm` for the `attaform/zod` entry. Runtime-dispatches\n * on schema shape: a Zod v4 schema (`def.type` truthy) routes to the\n * v4 adapter; a Zod v3 schema (or any other `AbstractSchema`) routes\n * to the v3 wrapper, which already accepts both Zod v3 input and\n * `AbstractSchema` directly via its built-in shape branch.\n *\n * Type-level dispatch happens via TWO typed overloads — v4 first, v3\n * second — plus an untyped impl. Each overload mirrors the matching\n * direct adapter's signature exactly, so a v4-schema call site pays\n * the same per-call depth cost as importing from `attaform/zod-v4`\n * directly. Overload resolution at concrete call sites commits to one\n * overload immediately on argument shape — no type-level dispatch tax.\n *\n * Tests and other call sites that need the equivalent of\n * `typeof useForm<X>` should reach for the `UseFormReturn<X>` /\n * `UseFormConfig<X>` helpers in `types-api.ts` — instantiation\n * expressions on overloaded functions follow brittle resolution rules,\n * and the helper types give a deterministic projection.\n *\n * This module is the FALLBACK path. Vite consumers see the\n * `attaform/vite` plugin's `resolveId` hook rewrite `attaform/zod`\n * imports to either `attaform/zod-v3` or `attaform/zod-v4` at build\n * time — in that case this dispatch never runs and the consumer\n * bundle ships only the matching adapter. Other bundlers (and\n * non-bundled ESM consumption) hit this dispatch instead, paying a\n * modest size cost for the convenience of a single hello-world import.\n *\n * Power users who want a guaranteed lean bundle on non-Vite tooling\n * can import directly from `attaform/zod-v3` or `attaform/zod-v4` —\n * those subpaths are never rewritten and never load the other\n * adapter.\n */\nimport { InvalidUseFormConfigError } from '../../core/errors'\nimport { isZodV4SchemaShape } from '../../core/zod-shape'\nimport type { ZodV4Internals } from './types-zod-major'\nimport { useForm as useFormV3 } from '../../composables/use-form'\nimport { useForm as useFormV4 } from '../zod-v4'\nimport type {\n  AbstractSchema,\n  FormKey,\n  ValidateOnConfig,\n  UseFormReturnType,\n  UseFormConfiguration,\n} from '../../types/types-api'\nimport type { DefaultValuesInput } from '../../types/types-core'\nimport type { SupportedRootSchema as SupportedRootSchemaV4 } from '../zod-v4/types-root'\nimport type { SupportedRootSchema as SupportedRootSchemaV3 } from '../zod-v3/types-root'\nimport type { V3FormOf, V3OutOf, V3ReadOf, V4FormOf, V4OutOf, V4ReadOf } from './types-projections'\n\n/**\n * Create a form bound to a Zod v4 schema.\n *\n * ```ts\n * import { useForm } from 'attaform/zod'\n * import { z } from 'zod'\n *\n * const form = useForm({\n *   schema: z.object({\n *     username: z.string().min(2, 'At least 2 characters'),\n *     password: z.string().min(8, 'At least 8 characters'),\n *   }),\n * })\n * ```\n *\n * The constraint intersects `ZodV4Internals` (the v4-only `_zod`\n * brand) so a v3 schema can't bind this overload even when `z`\n * resolves to v3 in a single-major consumer install; v3 schemas fall\n * through to the v3 overload below. See `types-zod-major.ts`.\n */\nexport function useForm<\n  Schema extends SupportedRootSchemaV4 & ZodV4Internals,\n  K extends FormKey = FormKey,\n>(\n  configuration: Omit<\n    UseFormConfiguration<\n      V4FormOf<Schema>,\n      V4OutOf<Schema>,\n      AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>,\n      DefaultValuesInput<V4FormOf<Schema>>,\n      K\n    >,\n    'schema' | 'validateOn' | 'debounceMs'\n  > & { schema: Schema } & ValidateOnConfig\n): UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K>\n/**\n * Create a form bound to a Zod v3 schema.\n *\n * ```ts\n * import { useForm } from 'attaform/zod'\n * import { z } from 'zod-v3'\n *\n * const form = useForm({\n *   schema: z.object({\n *     username: z.string().min(2, 'At least 2 characters'),\n *     password: z.string().min(8, 'At least 8 characters'),\n *   }),\n * })\n * ```\n *\n * v3 schemas match this overload; v4 schemas hit the v4 overload\n * above first and never reach here.\n */\nexport function useForm<Schema extends SupportedRootSchemaV3, K extends FormKey = FormKey>(\n  configuration: Omit<\n    UseFormConfiguration<\n      V3FormOf<Schema>,\n      V3OutOf<Schema>,\n      AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>,\n      DefaultValuesInput<V3FormOf<Schema>>,\n      K\n    >,\n    'schema' | 'validateOn' | 'debounceMs'\n  > & { schema: Schema } & ValidateOnConfig\n): UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K>\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useForm(configuration: any): any {\n  if (\n    configuration === undefined ||\n    configuration === null ||\n    (configuration as { schema?: unknown }).schema === undefined\n  ) {\n    throw new InvalidUseFormConfigError()\n  }\n  const { schema } = configuration as { schema: unknown }\n  if (isZodV4SchemaShape(schema)) {\n    return useFormV4(configuration as Parameters<typeof useFormV4>[0])\n  }\n  return useFormV3(configuration as Parameters<typeof useFormV3>[0])\n}\n","/**\n * Field-metadata write/read API for the unified `attaform/zod` entry.\n *\n * Storage is shared with both adapters via `field-meta-store` — a\n * payload written here is visible to whichever adapter the unified\n * `useForm` dispatches to at runtime, regardless of Zod major. No\n * `zod` runtime import; the type-only `import type` is erased at\n * build, so `attaform/zod` carries no `z.registry` reference even\n * when consumed by a Zod 3 project without the Vite plugin alias.\n *\n * The native v4 chain `schema.register(fieldMeta, payload)` continues\n * to work — Zod 4's `.register()` only calls `.add(this, payload)`\n * structurally, satisfied by the shared store.\n */\nimport type { z } from 'zod'\nimport type { FieldMetaPayload } from '../../core/field-meta'\nimport { fieldMetaStore, getFieldMetaForSchema } from '../../core/field-meta-store'\n\n// Zod v4's `$ZodRegistry` class isn't surfaced under the `z` namespace\n// of the classic external entry, but `z.registry()` returns one — so\n// `ReturnType<typeof z.registry<T>>` resolves to the registry type\n// without needing a direct import. The `import type` keeps the\n// reference type-only; nothing about `z.registry` lands in the bundle.\ntype ZodFieldMetaRegistry = ReturnType<typeof z.registry<FieldMetaPayload>>\n\n/**\n * The shared registry every Attaform-aware Zod schema can register\n * field metadata against, regardless of major. Same instance the v3\n * and v4 adapter entries expose — write in one place, read from\n * any.\n *\n * Cast to Zod 4's `$ZodRegistry<FieldMetaPayload>` so the native\n * `schema.register(fieldMeta, payload)` chain type-checks for v4\n * users; the runtime call only needs `.add` structurally, which the\n * shared store provides.\n */\nexport const fieldMeta = fieldMetaStore as unknown as ZodFieldMetaRegistry\n\n/**\n * Attach `payload` to `schema` in the shared registry and return a\n * clone of `schema` so each call gets its own identity (the registry\n * keys on schema reference, so cloning prevents last-write-wins\n * collisions for sub-schemas reused at multiple paths).\n *\n * Works on both Zod 3 and Zod 4 schemas — branches on the runtime\n * shape of the schema:\n * - Zod 4 schemas expose a public `.clone()` method; we call it.\n * - Zod 3 schemas don't, so we reconstruct via\n *   `new schema.constructor(schema._def)`.\n *\n * Both forms produce a fresh schema with the same effective\n * structure, so the registry slot is unique to this call site.\n */\nexport function withMeta<S>(schema: S, payload: FieldMetaPayload): S {\n  const target = schema as object\n  const existing = getFieldMetaForSchema(target) ?? {}\n  const cloned = cloneSchema(schema)\n  fieldMetaStore.add(cloned as object, { ...existing, ...payload })\n  return cloned\n}\n\nfunction cloneSchema<S>(schema: S): S {\n  const candidate = schema as { clone?: unknown; constructor: unknown; _def: unknown }\n  if (typeof candidate.clone === 'function') {\n    return (candidate.clone as () => S)()\n  }\n  // Zod 3 path: reconstruct via constructor + _def (no public\n  // `.clone()` on v3).\n  const Ctor = candidate.constructor as new (def: unknown) => S\n  return new Ctor(candidate._def)\n}\n"],"names":["InvalidUseFormConfigError","useFormV4","useFormV3","fieldMetaStore","getFieldMetaForSchema"],"mappings":";;;;;;;;AAwCO,SAAS,mBAAmB,KAAA,EAAqC;AACtE,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,KAAU,MAAM,OAAO,KAAA;AACxD,EAAA,MAAM,MAAO,KAAA,CAA4B,GAAA;AACzC,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,MAAM,OAAO,KAAA;AACpD,EAAA,OAAO,OAAQ,IAA2B,IAAA,KAAS,QAAA;AACrD;;ACuEO,SAAS,QAAQ,aAAA,EAAyB;AAC/C,EAAA,IACE,kBAAkB,MAAA,IAClB,aAAA,KAAkB,IAAA,IACjB,aAAA,CAAuC,WAAW,MAAA,EACnD;AACA,IAAA,MAAM,IAAIA,+BAAA,EAA0B;AAAA,EACtC;AACA,EAAA,MAAM,EAAE,QAAO,GAAI,aAAA;AACnB,EAAA,IAAI,kBAAA,CAAmB,MAAM,CAAA,EAAG;AAC9B,IAAA,OAAOC,cAAU,aAAgD,CAAA;AAAA,EACnE;AACA,EAAA,OAAOC,kBAAU,aAAgD,CAAA;AACnE;;AC7FO,MAAM,SAAA,GAAYC;AAiBlB,SAAS,QAAA,CAAY,QAAW,OAAA,EAA8B;AACnE,EAAA,MAAM,MAAA,GAAS,MAAA;AACf,EAAA,MAAM,QAAA,GAAWC,mCAAA,CAAsB,MAAM,CAAA,IAAK,EAAC;AACnD,EAAA,MAAM,MAAA,GAAS,YAAY,MAAM,CAAA;AACjC,EAAAD,4BAAA,CAAe,IAAI,MAAA,EAAkB,EAAE,GAAG,QAAA,EAAU,GAAG,SAAS,CAAA;AAChE,EAAA,OAAO,MAAA;AACT;AAEA,SAAS,YAAe,MAAA,EAAc;AACpC,EAAA,MAAM,SAAA,GAAY,MAAA;AAClB,EAAA,IAAI,OAAO,SAAA,CAAU,KAAA,KAAU,UAAA,EAAY;AACzC,IAAA,OAAQ,UAAU,KAAA,EAAkB;AAAA,EACtC;AAGA,EAAA,MAAM,OAAO,SAAA,CAAU,WAAA;AACvB,EAAA,OAAO,IAAI,IAAA,CAAK,SAAA,CAAU,IAAI,CAAA;AAChC;;;;;;;;;;;;;;"}
+{"version":3,"file":"zod.cjs","sources":["../src/runtime/core/zod-shape.ts","../src/runtime/adapters/unified/use-form.ts","../src/runtime/adapters/unified/field-meta.ts"],"sourcesContent":["/**\n * Shape detectors for Zod schemas. Used by the unified `attaform/zod`\n * entry's runtime dispatch (`runtime/adapters/unified/use-form.ts`)\n * to route to the v3 or v4 adapter based on the schema's runtime\n * shape. Mirrors the discrimination already used by the v4\n * introspection helper (`adapters/zod-v4/introspect.ts`'s\n * `assertZodVersion`, which reads `def.type`) and the v3 wrapper's\n * legitimate-input branch (`composables/use-form.ts`'s `isZodType`,\n * which reads `_def`).\n *\n * Why this discriminator and not `_zod` / `_def`:\n * - Zod v4 retained `_def` for backward compat — reading `_def` alone\n *   misclassifies v4 schemas as v3.\n * - Zod v4's stable shape is `def.type: string` (lowercase tag like\n *   `'object'`); Zod v3's is `_def.typeName: string` (capitalised tag\n *   like `'ZodObject'`). Both are checked structurally so consumers\n *   who alias one Zod major to a non-standard import path still work.\n */\n\ninterface ZodV4Shape {\n  def: { type: unknown }\n}\n\ninterface ZodV3Shape {\n  _def: { typeName: unknown }\n}\n\n/**\n * Returns true when `value` looks like a Zod schema of either major\n * version. Convenience wrapper around the v3 / v4 detectors.\n */\nexport function isZodSchemaShape(value: unknown): boolean {\n  return isZodV4SchemaShape(value) || isZodV3SchemaShape(value)\n}\n\n/**\n * Returns true when `value` looks like a Zod v4 schema (has\n * `def.type: string`). Used by the unified entry's runtime-dispatch\n * to route to the v4 adapter.\n */\nexport function isZodV4SchemaShape(value: unknown): value is ZodV4Shape {\n  if (typeof value !== 'object' || value === null) return false\n  const def = (value as { def?: unknown }).def\n  if (typeof def !== 'object' || def === null) return false\n  return typeof (def as { type?: unknown }).type === 'string'\n}\n\n/**\n * Returns true when `value` looks like a Zod v3 schema (has\n * `_def.typeName: string`). Kept distinct from `isZodV4SchemaShape`\n * because some v4 schemas also expose `_def` for backward compat —\n * the v4 detector wins first in `isZodSchemaShape`.\n */\nexport function isZodV3SchemaShape(value: unknown): value is ZodV3Shape {\n  if (typeof value !== 'object' || value === null) return false\n  const def = (value as { _def?: unknown })._def\n  if (typeof def !== 'object' || def === null) return false\n  return typeof (def as { typeName?: unknown }).typeName === 'string'\n}\n","/**\n * Unified `useForm` for the `attaform/zod` entry. Runtime-dispatches\n * on schema shape: a Zod v4 schema (`def.type` truthy) routes to the\n * v4 adapter; a Zod v3 schema (or any other `AbstractSchema`) routes\n * to the v3 wrapper, which already accepts both Zod v3 input and\n * `AbstractSchema` directly via its built-in shape branch.\n *\n * Type-level dispatch happens via TWO typed overloads — v4 first, v3\n * second — plus an untyped impl. Each overload mirrors the matching\n * direct adapter's signature exactly, so a v4-schema call site pays\n * the same per-call depth cost as importing from `attaform/zod-v4`\n * directly. Overload resolution at concrete call sites commits to one\n * overload immediately on argument shape — no type-level dispatch tax.\n *\n * Tests and other call sites that need the equivalent of\n * `typeof useForm<X>` should reach for the `UseFormReturn<X>` /\n * `UseFormConfig<X>` helpers in `types-api.ts` — instantiation\n * expressions on overloaded functions follow brittle resolution rules,\n * and the helper types give a deterministic projection.\n *\n * This module is the FALLBACK path. Vite consumers see the\n * `attaform/vite` plugin's `resolveId` hook rewrite `attaform/zod`\n * imports to either `attaform/zod-v3` or `attaform/zod-v4` at build\n * time — in that case this dispatch never runs and the consumer\n * bundle ships only the matching adapter. Other bundlers (and\n * non-bundled ESM consumption) hit this dispatch instead, paying a\n * modest size cost for the convenience of a single hello-world import.\n *\n * Power users who want a guaranteed lean bundle on non-Vite tooling\n * can import directly from `attaform/zod-v3` or `attaform/zod-v4` —\n * those subpaths are never rewritten and never load the other\n * adapter.\n */\nimport { InvalidUseFormConfigError } from '../../core/errors'\nimport { isZodV4SchemaShape } from '../../core/zod-shape'\nimport type { ZodV4Internals } from './types-zod-major'\nimport { useForm as useFormV3 } from '../../composables/use-form'\nimport { useForm as useFormV4 } from '../zod-v4'\nimport type {\n  AbstractSchema,\n  FormKey,\n  ValidateOnConfig,\n  UseFormReturnType,\n  UseFormConfiguration,\n} from '../../types/types-api'\nimport type { AcceptableDefaults } from '../../types/types-core'\nimport type { SupportedRootSchema as SupportedRootSchemaV4 } from '../zod-v4/types-root'\nimport type { SupportedRootSchema as SupportedRootSchemaV3 } from '../zod-v3/types-root'\nimport type {\n  V3FormOf,\n  V3OutOf,\n  V3ReadOf,\n  V3SchemaInput,\n  V4FormOf,\n  V4OutOf,\n  V4ReadOf,\n  V4SchemaInput,\n} from './types-projections'\n\n/**\n * Create a form bound to a Zod v4 schema.\n *\n * ```ts\n * import { useForm } from 'attaform/zod'\n * import { z } from 'zod'\n *\n * const form = useForm({\n *   schema: z.object({\n *     username: z.string().min(2, 'At least 2 characters'),\n *     password: z.string().min(8, 'At least 8 characters'),\n *   }),\n * })\n * ```\n *\n * The constraint intersects `ZodV4Internals` (the v4-only `_zod`\n * brand) so a v3 schema can't bind this overload even when `z`\n * resolves to v3 in a single-major consumer install; v3 schemas fall\n * through to the v3 overload below. See `types-zod-major.ts`.\n */\nexport function useForm<\n  Schema extends SupportedRootSchemaV4 & ZodV4Internals,\n  K extends FormKey = FormKey,\n>(\n  configuration: Omit<\n    UseFormConfiguration<\n      V4FormOf<Schema>,\n      V4OutOf<Schema>,\n      AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>,\n      // `defaultValues` is Omitted below and re-supplied via the\n      // `AcceptableDefaults` intersection, so this `DefaultValues` slot is\n      // inert. `never` keeps it from re-instantiating the deep\n      // `DefaultValuesInput` cascade here — that redundant instantiation,\n      // across both overloads at a concrete call site, tips the bundled\n      // `.d.ts` into TS2589.\n      never,\n      K\n    >,\n    'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'\n  > & {\n    schema: Schema\n    // #422: the `AcceptableDefaults` slot adds the schema's own input\n    // (`V4SchemaInput<Schema>`) as a reflexive escape arm so a generic form\n    // wrapper forwarding `defaultValues` does not trip TS2589 / TS2769.\n    // The arm is redundant at concrete call sites (a schema's input is a\n    // subset of its `DefaultValuesInput`), so concrete checking is\n    // unchanged. The return type never references the slot, so field\n    // inference is preserved through the wrapper. See `AcceptableDefaults`.\n    defaultValues?: AcceptableDefaults<V4FormOf<Schema>, V4SchemaInput<Schema>>\n  } & ValidateOnConfig\n): UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K>\n/**\n * Create a form bound to a Zod v3 schema.\n *\n * ```ts\n * import { useForm } from 'attaform/zod'\n * import { z } from 'zod-v3'\n *\n * const form = useForm({\n *   schema: z.object({\n *     username: z.string().min(2, 'At least 2 characters'),\n *     password: z.string().min(8, 'At least 8 characters'),\n *   }),\n * })\n * ```\n *\n * v3 schemas match this overload; v4 schemas hit the v4 overload\n * above first and never reach here.\n */\nexport function useForm<Schema extends SupportedRootSchemaV3, K extends FormKey = FormKey>(\n  configuration: Omit<\n    UseFormConfiguration<\n      V3FormOf<Schema>,\n      V3OutOf<Schema>,\n      AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>,\n      // Inert `DefaultValues` slot — see the v4 overload above.\n      never,\n      K\n    >,\n    'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'\n  > & {\n    schema: Schema\n    // #422 — see the v4 overload above for the escape-arm rationale.\n    defaultValues?: AcceptableDefaults<V3FormOf<Schema>, V3SchemaInput<Schema>>\n  } & ValidateOnConfig\n): UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K>\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useForm(configuration: any): any {\n  if (\n    configuration === undefined ||\n    configuration === null ||\n    (configuration as { schema?: unknown }).schema === undefined\n  ) {\n    throw new InvalidUseFormConfigError()\n  }\n  const { schema } = configuration as { schema: unknown }\n  if (isZodV4SchemaShape(schema)) {\n    return useFormV4(configuration as Parameters<typeof useFormV4>[0])\n  }\n  return useFormV3(configuration as Parameters<typeof useFormV3>[0])\n}\n","/**\n * Field-metadata write/read API for the unified `attaform/zod` entry.\n *\n * Storage is shared with both adapters via `field-meta-store` — a\n * payload written here is visible to whichever adapter the unified\n * `useForm` dispatches to at runtime, regardless of Zod major. No\n * `zod` runtime import; the type-only `import type` is erased at\n * build, so `attaform/zod` carries no `z.registry` reference even\n * when consumed by a Zod 3 project without the Vite plugin alias.\n *\n * The native v4 chain `schema.register(fieldMeta, payload)` continues\n * to work — Zod 4's `.register()` only calls `.add(this, payload)`\n * structurally, satisfied by the shared store.\n */\nimport type { z } from 'zod'\nimport type { FieldMetaPayload } from '../../core/field-meta'\nimport { fieldMetaStore, getFieldMetaForSchema } from '../../core/field-meta-store'\n\n// Zod v4's `$ZodRegistry` class isn't surfaced under the `z` namespace\n// of the classic external entry, but `z.registry()` returns one — so\n// `ReturnType<typeof z.registry<T>>` resolves to the registry type\n// without needing a direct import. The `import type` keeps the\n// reference type-only; nothing about `z.registry` lands in the bundle.\ntype ZodFieldMetaRegistry = ReturnType<typeof z.registry<FieldMetaPayload>>\n\n/**\n * The shared registry every Attaform-aware Zod schema can register\n * field metadata against, regardless of major. Same instance the v3\n * and v4 adapter entries expose — write in one place, read from\n * any.\n *\n * Cast to Zod 4's `$ZodRegistry<FieldMetaPayload>` so the native\n * `schema.register(fieldMeta, payload)` chain type-checks for v4\n * users; the runtime call only needs `.add` structurally, which the\n * shared store provides.\n */\nexport const fieldMeta = fieldMetaStore as unknown as ZodFieldMetaRegistry\n\n/**\n * Attach `payload` to `schema` in the shared registry and return a\n * clone of `schema` so each call gets its own identity (the registry\n * keys on schema reference, so cloning prevents last-write-wins\n * collisions for sub-schemas reused at multiple paths).\n *\n * Works on both Zod 3 and Zod 4 schemas — branches on the runtime\n * shape of the schema:\n * - Zod 4 schemas expose a public `.clone()` method; we call it.\n * - Zod 3 schemas don't, so we reconstruct via\n *   `new schema.constructor(schema._def)`.\n *\n * Both forms produce a fresh schema with the same effective\n * structure, so the registry slot is unique to this call site.\n */\nexport function withMeta<S>(schema: S, payload: FieldMetaPayload): S {\n  const target = schema as object\n  const existing = getFieldMetaForSchema(target) ?? {}\n  const cloned = cloneSchema(schema)\n  fieldMetaStore.add(cloned as object, { ...existing, ...payload })\n  return cloned\n}\n\nfunction cloneSchema<S>(schema: S): S {\n  const candidate = schema as { clone?: unknown; constructor: unknown; _def: unknown }\n  if (typeof candidate.clone === 'function') {\n    return (candidate.clone as () => S)()\n  }\n  // Zod 3 path: reconstruct via constructor + _def (no public\n  // `.clone()` on v3).\n  const Ctor = candidate.constructor as new (def: unknown) => S\n  return new Ctor(candidate._def)\n}\n"],"names":["InvalidUseFormConfigError","useFormV4","useFormV3","fieldMetaStore","getFieldMetaForSchema"],"mappings":";;;;;;;;AAwCO,SAAS,mBAAmB,KAAA,EAAqC;AACtE,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,KAAU,MAAM,OAAO,KAAA;AACxD,EAAA,MAAM,MAAO,KAAA,CAA4B,GAAA;AACzC,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,MAAM,OAAO,KAAA;AACpD,EAAA,OAAO,OAAQ,IAA2B,IAAA,KAAS,QAAA;AACrD;;ACqGO,SAAS,QAAQ,aAAA,EAAyB;AAC/C,EAAA,IACE,kBAAkB,MAAA,IAClB,aAAA,KAAkB,IAAA,IACjB,aAAA,CAAuC,WAAW,MAAA,EACnD;AACA,IAAA,MAAM,IAAIA,+BAAA,EAA0B;AAAA,EACtC;AACA,EAAA,MAAM,EAAE,QAAO,GAAI,aAAA;AACnB,EAAA,IAAI,kBAAA,CAAmB,MAAM,CAAA,EAAG;AAC9B,IAAA,OAAOC,cAAU,aAAgD,CAAA;AAAA,EACnE;AACA,EAAA,OAAOC,kBAAU,aAAgD,CAAA;AACnE;;AC3HO,MAAM,SAAA,GAAYC;AAiBlB,SAAS,QAAA,CAAY,QAAW,OAAA,EAA8B;AACnE,EAAA,MAAM,MAAA,GAAS,MAAA;AACf,EAAA,MAAM,QAAA,GAAWC,mCAAA,CAAsB,MAAM,CAAA,IAAK,EAAC;AACnD,EAAA,MAAM,MAAA,GAAS,YAAY,MAAM,CAAA;AACjC,EAAAD,4BAAA,CAAe,IAAI,MAAA,EAAkB,EAAE,GAAG,QAAA,EAAU,GAAG,SAAS,CAAA;AAChE,EAAA,OAAO,MAAA;AACT;AAEA,SAAS,YAAe,MAAA,EAAc;AACpC,EAAA,MAAM,SAAA,GAAY,MAAA;AAClB,EAAA,IAAI,OAAO,SAAA,CAAU,KAAA,KAAU,UAAA,EAAY;AACzC,IAAA,OAAQ,UAAU,KAAA,EAAkB;AAAA,EACtC;AAGA,EAAA,MAAM,OAAO,SAAA,CAAU,WAAA;AACvB,EAAA,OAAO,IAAI,IAAA,CAAK,SAAA,CAAU,IAAI,CAAA;AAChC;;;;;;;;;;;;;;"}

package/dist/zod.d.cts

@@ -1,10 +1,10 @@
-import { G as GenericForm, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, D as DefaultValuesInput, af as ValidateOnConfig, b as UseFormReturnType, q as FieldMetaPayload } from './shared/attaform.GJbSmwLB.cjs';
-export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.GJbSmwLB.cjs';
-import { S as SupportedRootSchema, b as StorageShape } from './shared/attaform.K-3glmiT.cjs';
-export { P as PathInput, a as PathOutput } from './shared/attaform.K-3glmiT.cjs';
+import { G as GenericForm, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, ar as AcceptableDefaults, af as ValidateOnConfig, b as UseFormReturnType, D as DefaultValuesInput, q as FieldMetaPayload } from './shared/attaform.DUc6cetN.cjs';
+export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.DUc6cetN.cjs';
+import { S as SupportedRootSchema, b as StorageShape } from './shared/attaform.Bx6pgrIy.cjs';
+export { P as PathInput, a as PathOutput } from './shared/attaform.Bx6pgrIy.cjs';
 import { S as SupportedRootSchema$1, U as UnwrapZodRoot, a as StorageShape$1 } from './shared/attaform.DdjDqTah.cjs';
 import { z } from 'zod';
-export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.DdUYEhkV.cjs';
+export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.DHjRN5JP.cjs';
 import 'vue';
 
 /**
@@ -61,6 +61,20 @@ type ZodV4Internals = {
  * call sites.
  */
 
+/**
+ * The schema's own input type, exactly as a consumer would reference it
+ * (`z.input<S>`) — NOT routed through `GenericForm` / `UnwrapZodRoot`. This
+ * is the reflexive escape arm `AcceptableDefaults` adds to the
+ * `defaultValues` slot so a generic form wrapper forwarding `z.input<S>`
+ * type-checks under a free `S` (#422). It must stay syntactically identical
+ * to what the wrapper forwards: wrapping it in a conditional makes it a
+ * deferred conditional that no longer matches the forwarded value under a
+ * generic. Wrong-major schemas can't actually bind the slot — they are
+ * rejected at the overload's `schema` constraint — so the raw input never
+ * widens the slot for the wrong major.
+ */
+type V4SchemaInput<S extends SupportedRootSchema> = z.input<S>;
+type V3SchemaInput<S extends SupportedRootSchema$1> = z.input<S>;
 type V4FormOf<S extends SupportedRootSchema> = z.input<S> extends GenericForm ? z.input<S> : never;
 type V4OutOf<S extends SupportedRootSchema> = z.output<S> extends GenericForm ? z.output<S> : never;
 type V4ReadOf<S extends SupportedRootSchema> = StorageShape<S> extends GenericForm ? StorageShape<S> : never;
@@ -88,8 +102,9 @@ type V3ReadOf<S extends SupportedRootSchema$1> = StorageShape$1<UnwrapZodRoot<S>
  * resolves to v3 in a single-major consumer install; v3 schemas fall
  * through to the v3 overload below. See `types-zod-major.ts`.
  */
-declare function useForm<Schema extends SupportedRootSchema & ZodV4Internals, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<V4FormOf<Schema>, V4OutOf<Schema>, AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>, DefaultValuesInput<V4FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
+declare function useForm<Schema extends SupportedRootSchema & ZodV4Internals, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<V4FormOf<Schema>, V4OutOf<Schema>, AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>, never, K>, 'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'> & {
     schema: Schema;
+    defaultValues?: AcceptableDefaults<V4FormOf<Schema>, V4SchemaInput<Schema>>;
 } & ValidateOnConfig): UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K>;
 /**
  * Create a form bound to a Zod v3 schema.
@@ -109,8 +124,9 @@ declare function useForm<Schema extends SupportedRootSchema & ZodV4Internals, K
  * v3 schemas match this overload; v4 schemas hit the v4 overload
  * above first and never reach here.
  */
-declare function useForm<Schema extends SupportedRootSchema$1, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<V3FormOf<Schema>, V3OutOf<Schema>, AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>, DefaultValuesInput<V3FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
+declare function useForm<Schema extends SupportedRootSchema$1, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<V3FormOf<Schema>, V3OutOf<Schema>, AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>, never, K>, 'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'> & {
     schema: Schema;
+    defaultValues?: AcceptableDefaults<V3FormOf<Schema>, V3SchemaInput<Schema>>;
 } & ValidateOnConfig): UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K>;
 
 /**