attaform 0.30.0 → 0.30.1

package/dist/shared/{attaform.Rc9u4Vfw.d.mts → attaform.2FslhB9R.d.mts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { G as GenericForm, l as FlatPath, s as NestedType, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, aq as AcceptableDefaults, ac as ValidateOnConfig, a as UseFormReturnType } from './attaform.bKLzMU0o.mjs';
+import { G as GenericForm, l as FlatPath, s as NestedType, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, aq as AcceptableDefaults, ac as ValidateOnConfig, a as UseFormReturnType } from './attaform.Br8EBn5B.mjs';
 
 /**
  * The Zod v4 schema roots `useForm` accepts. A fixed-shape
@@ -34,60 +34,54 @@ import { G as GenericForm, l as FlatPath, s as NestedType, F as FormKey, U as Us
 type SupportedRootSchema = z.ZodObject<z.ZodRawShape> | z.ZodRecord | z.ZodDiscriminatedUnion<readonly z.ZodObject<z.ZodRawShape>[], string>;
 
 /**
- * The shape `form.values.<key>` returns at runtime.
- *
- * Per leaf:
- *
- * 1. Schema-side input normalizers — `z.preprocess(fn, inner)` AND
- *    `z.coerce.X()`. Zod v4 represents these differently
- *    (`ZodPipe<ZodTransform, inner>` for preprocess; a primitive
- *    with `def.coerce === true` for coerce), but they share the
- *    same type-level marker: `_zod.input` is `unknown`. The
- *    normalizer runs at parse time, NOT at the write boundary, so
- *    storage holds the consumer's raw input and the type collapses
- *    to `unknown` to match. Reach the typed value via
- *    `handleSubmit`, `validate`, or `parse` — they re-parse
- *    storage through the wrapper.
- *
- * 2. `inner.transform(fn)` — compiles to `ZodPipe<inner, ZodTransform>`.
- *    Transforms fire at submit / validate, NOT at the write boundary,
- *    so storage holds whatever `inner` stores. Recurse `StorageShape`
- *    on `inner` so a defaulted leaf inside `inner` still reads `T`
- *    (not `T | undefined`).
- *
- *    A bare top-level `ZodTransform` (no `in` schema) reads
- *    `_zod.input` directly — there's no inner to recurse into.
- *
- * 3. Codec / generic pipe — neither side is a transform. Read
- *    `_zod.output`. Codecs aren't write-boundary-synthesized, so the
+ * The shape `form.values.<key>` returns at runtime. Four cases per leaf:
+ *
+ * 1. A schema-side input normalizer, meaning `z.preprocess(fn, inner)`
+ *    or `z.coerce.X()`. v4 represents the two differently, a
+ *    `ZodPipe<ZodTransform, inner>` against a primitive with
+ *    `def.coerce === true`, but they share one type-level marker:
+ *    `_zod.input` is `unknown`. The normalizer runs at PARSE time, not
+ *    at the write boundary, so storage holds the consumer's raw input
+ *    and the type collapses to `unknown` to match. `handleSubmit`,
+ *    `validate` and `parse` re-parse storage through the wrapper, so
+ *    the typed value is reachable there.
+ *
+ * 2. `inner.transform(fn)`, which compiles to `ZodPipe<inner,
+ *    ZodTransform>`. A transform fires at submit or validate, not at the
+ *    write boundary, so storage holds whatever `inner` stores.
+ *    `StorageShape` recurses on `inner`, so a defaulted leaf inside it
+ *    still reads `T` rather than `T | undefined`. A bare top-level
+ *    `ZodTransform`, with no `in` schema, reads `_zod.input` directly,
+ *    having no inner to recurse into.
+ *
+ * 3. A codec or generic pipe, where neither side is a transform: read
+ *    `_zod.output`. A codec is not write-boundary-synthesized, so the
  *    post-parse view is the only honest storage type.
  *
- * 4. Everything else (defaults, catch, readonly, optional, primitives,
- *    nested objects) — read `_zod.output`. Defaults and catches fire
- *    at parse time, so the post-init view is what storage holds.
- *    Nested objects delegate to Zod's own recursion on `_zod.output`,
+ * 4. Everything else, defaults, catch, readonly, optional, primitives
+ *    and nested objects: read `_zod.output`. Defaults and catches fire
+ *    at parse time, so the post-init view is what storage holds, and a
+ *    nested object delegates to Zod's own recursion on `_zod.output`,
  *    which peels nested defaults inside structural containers.
  *
- * Detection order: case 1 wins via the `_zod.input` IsUnknown check
- * before the pipe/transform cascade fires, so wrapped variants like
- * `z.coerce.number().optional()` (input = `unknown | undefined` →
- * collapses to `unknown`) and `z.preprocess(fn, z.object(...))` (input
- * = `unknown`) both land on `unknown` without descending. The IsAny
- * filter keeps `z.any()` from being mistaken for coerce.
- *
- * Implementation note: direct `_zod` property access mirrors Zod's
- * own `$InferObjectOutput` / `$InferObjectInput`, which read
- * `T[k]['_zod']['output']` / `T[k]['_zod']['input']` directly rather
- * than wrapping in the top-level `output<T>` / `input<T>` conditional.
- * Wrapping per key spawns a fresh conditional instantiation for every
- * key; Volar's web-worker checker collapses that per-key walk to
- * `any` once the schema is non-trivial. Property access has no
- * conditional and resolves cleanly under the same budget.
- *
- * Shape access also goes through `_zod.def.shape` rather than
- * `infer Shape from z.ZodObject<Shape>` — the latter collapses to the
- * `$ZodShape` upper bound in the same worker because of
- * `z.ZodObject`'s `out Shape` covariance markers.
+ * Case 1 wins first, on the `_zod.input` IsUnknown check, before the
+ * pipe and transform cascade can fire. So `z.coerce.number().optional()`
+ * (input `unknown | undefined`, collapsing to `unknown`) and
+ * `z.preprocess(fn, z.object(...))` (input `unknown`) both land on
+ * `unknown` without descending, while the IsAny filter keeps `z.any()`
+ * from being read as coerce.
+ *
+ * The direct `_zod` property access is deliberate, and matches Zod's own
+ * `$InferObjectOutput` / `$InferObjectInput`, which read
+ * `T[k]['_zod']['output']` rather than wrapping in the top-level
+ * `output<T>` conditional. Wrapping per key spawns a fresh conditional
+ * instantiation for every key, and Volar's web-worker checker collapses
+ * that per-key walk to `any` once the schema is non-trivial. Property
+ * access has no conditional and resolves cleanly on the same budget.
+ * Shape access goes through `_zod.def.shape` for the same reason: `infer
+ * Shape from z.ZodObject<Shape>` collapses to the `$ZodShape` upper
+ * bound in that worker, because of `z.ZodObject`'s `out Shape`
+ * covariance markers.
  */
 type StorageShape<S> = S extends {
     _zod: {
@@ -100,10 +94,10 @@ type StorageShape<S> = S extends {
     [K in keyof Shape]-?: StorageLeaf<Shape[K]>;
 } : StorageLeaf<S>;
 /**
- * Detects a schema whose `_zod.input` is `unknown` — the marker both
- * `z.preprocess(fn, _)` and `z.coerce.X()` share in Zod v4. Excludes
- * `any` via the canonical `0 extends 1 & T` test so `z.any()` leaves
- * fall through to the cascade below and keep their `any` typing.
+ * Detect a schema whose `_zod.input` is `unknown`, the marker
+ * `z.preprocess(fn, _)` and `z.coerce.X()` share in v4. `any` is
+ * excluded through the canonical `0 extends 1 & T` test, so a `z.any()`
+ * leaf falls through to the cascade below and keeps its `any`.
  */
 type InputIsUnknown<L> = L extends {
     _zod: {
@@ -111,12 +105,11 @@ type InputIsUnknown<L> = L extends {
     };
 } ? 0 extends 1 & In ? false : unknown extends In ? true : false : false;
 /**
- * Implementation-detail per-leaf branching for `StorageShape`.
- * Exported so the bundled `.d.ts` carries a single alias body —
- * every leaf of a Zod object schema otherwise re-emits the full
- * pipe / transform / default conditional ladder, which compounds
- * badly with multiple complex schemas in the same scope. Consumers
- * should reach for `StorageShape` instead.
+ * The per-leaf branching behind `StorageShape`. It is exported so the
+ * bundled `.d.ts` carries ONE alias body: otherwise every leaf of a Zod
+ * object re-emits the full pipe / transform / default conditional
+ * ladder, which compounds badly once several complex schemas share a
+ * scope. Reach for `StorageShape` instead.
  */
 type StorageLeaf<L> = InputIsUnknown<L> extends true ? unknown : L extends {
     _zod: {
@@ -159,10 +152,10 @@ type StorageLeaf<L> = InputIsUnknown<L> extends true ? unknown : L extends {
  */
 
 /**
- * Type of the value accepted at `Path` for `setValue` / `defaultValues`
- * — the schema's `z.input<Schema>` shape at that path. Matches what
- * `form.values.X` returns at runtime (the honest input view storage
- * holds before transforms run).
+ * What `setValue` and `defaultValues` accept at `Path`: the schema's
+ * `z.input<Schema>` shape there. It matches what `form.values.X` returns
+ * at runtime, storage holding the honest input view until transforms
+ * run.
  *
  * ```ts
  * const schema = z.object({
@@ -173,9 +166,9 @@ type StorageLeaf<L> = InputIsUnknown<L> extends true ? unknown : L extends {
  */
 type PathInput<Schema extends z.ZodType, Path extends string> = z.input<Schema> extends GenericForm ? Path extends FlatPath<z.input<Schema>> ? NestedType<z.input<Schema>, Path> : never : never;
 /**
- * Type produced at `Path` after the full parse pipeline — the schema's
- * `z.output<Schema>` shape at that path. Matches the `data` payload of
- * `form.parse()` and the value handed to `handleSubmit`'s callback.
+ * What `Path` holds after the full parse pipeline: the schema's
+ * `z.output<Schema>` shape there. It matches `form.parse()`'s `data` and
+ * the value `handleSubmit`'s callback receives.
  *
  * ```ts
  * const schema = z.object({
@@ -185,6 +178,19 @@ type PathInput<Schema extends z.ZodType, Path extends string> = z.input<Schema>
  * ```
  */
 type PathOutput<Schema extends z.ZodType, Path extends string> = z.output<Schema> extends GenericForm ? Path extends FlatPath<z.output<Schema>> ? NestedType<z.output<Schema>, Path> : never : never;
+/**
+ * Factor the three identical-shape conditionals out of `useForm`'s public
+ * signature, so the bundled `.d.ts` carries one alias per shape instead
+ * of re-inlining `z.input<Schema> extends GenericForm ? z.input<Schema>
+ * : never` four times. That inlining is what produces TS2589 ("Type
+ * instantiation is excessively deep") at a consumer call site holding a
+ * discriminated union, a transform pipe, or a deep `.register()` chain.
+ * Each alias computes once per `Schema` instantiation, and downstream
+ * generics ride it rather than re-evaluating the conditional.
+ */
+type FormOf<Schema extends SupportedRootSchema> = z.input<Schema> extends GenericForm ? z.input<Schema> : never;
+type OutOf<Schema extends SupportedRootSchema> = z.output<Schema> extends GenericForm ? z.output<Schema> : never;
+type ReadOf<Schema extends SupportedRootSchema> = StorageShape<Schema> extends GenericForm ? StorageShape<Schema> : never;
 /**
  * Create a form bound to a Zod v4 schema.
  *
@@ -192,37 +198,19 @@ type PathOutput<Schema extends z.ZodType, Path extends string> = z.output<Schema
  * import { useForm } from 'attaform/zod'
  * import { z } from 'zod'
  *
- * const form = useForm({
- *   schema: z.object({
- *     email: z.email(),
- *     password: z.string().min(8),
- *   }),
- *   defaultValues: { email: '' },
+ * const schema = z.object({
+ *   email: z.email(),
+ *   password: z.string().min(8),
  * })
- * ```
  *
- * Returns a form API exposing `register`, `values`, `errors`,
- * `fields`, `setValue`, `handleSubmit`, `meta`, field-array
- * helpers, and more. See `UseFormReturnType` for the full
- * surface.
+ * const form = useForm({ schema, defaultValues: { email: '' } })
+ * ```
  *
- * For Zod v3, import from `attaform/zod-v3` instead.
+ * The returned form carries `register`, `values`, `errors`, `fields`,
+ * `setValue`, `handleSubmit`, `meta` and the field-array helpers; see
+ * `UseFormReturnType` for the whole surface. For Zod v3, import from
+ * `attaform/zod-v3`.
  */
-/**
- * `FormOf` / `OutOf` / `ReadOf` factor the three identical-shape
- * conditionals out of `useForm`'s public signature. The bundled
- * `.d.ts` then carries one alias per shape rather than re-inlining
- * `z.input<Schema> extends GenericForm ? z.input<Schema> : never`
- * four times — which is what produces TS2589 ("Type instantiation
- * is excessively deep") on consumer call sites with complex schemas
- * (discriminated unions, transform pipes, deep `.register()` chains).
- * Each alias is computed once per `Schema` instantiation; downstream
- * generics ride on the alias rather than re-evaluating the
- * conditional from scratch.
- */
-type FormOf<Schema extends SupportedRootSchema> = z.input<Schema> extends GenericForm ? z.input<Schema> : never;
-type OutOf<Schema extends SupportedRootSchema> = z.output<Schema> extends GenericForm ? z.output<Schema> : never;
-type ReadOf<Schema extends SupportedRootSchema> = StorageShape<Schema> extends GenericForm ? StorageShape<Schema> : never;
 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>>;

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.ByWP6kSx.mjs → attaform.B2iebkPA.mjs}

@@ -1,7 +1,7 @@
 import { a as InvalidUseFormConfigError } from './attaform.CdZIEf7_.mjs';
-import { u as useForm$2 } from './attaform.CJ8DpRGj.mjs';
-import { u as useForm$1 } from './attaform.BXneBxEj.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform.CUfrMK7t.mjs';
+import { u as useForm$2 } from './attaform.D_pt1gOj.mjs';
+import { u as useForm$1 } from './attaform.CO918TdU.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform.DRsANMok.mjs';
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;

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;