attaform 0.29.0 → 0.30.1

package/dist/rspack.d.mts

@@ -1,7 +1,8 @@
 import { W as WebpackFamilyPlugin, a as WebpackFamilyPluginOptions } from './shared/attaform.C9fPTxjB.mjs';
 
 /**
- * `attaform/rspack` — Rspack plugin that rewrites `attaform/zod` imports
+ * `attaform/rspack`, the Rspack plugin that rewrites `attaform/zod`
+ * imports
  * to the single matching adapter subpath (`attaform/zod-v3` or
  * `attaform/zod-v4`) at build time, based on the consumer's installed Zod
  * major. Without it, Rspack ships both adapters because the unified
@@ -20,16 +21,12 @@ import { W as WebpackFamilyPlugin, a as WebpackFamilyPluginOptions } from './sha
  * so this shares its body with `attaform/webpack` via
  * `createWebpackFamilyPlugin`; only the diagnostic tag differs.
  *
- * This plugin only does the adapter rewrite. The Vue SFC `v-register`
- * transforms that `attaform/vite` wires (load-bearing for SSR initial
- * render) are `@vitejs/plugin-vue`-specific and do not transfer; a
- * non-Vite consumer that needs them wires `attaform/transforms` into
- * their Vue compiler separately. The `v-register` directive itself is
- * also delivered by the Vite plugin's compile-time binding, so outside
- * that pipeline register it once per app:
- *
- *   import { installVRegister } from 'attaform/directive'
- *   installVRegister(app)
+ * The adapter rewrite is all this plugin does. Two things
+ * `attaform/vite` also provides do NOT transfer, because both are
+ * `@vitejs/plugin-vue`-specific: wire `attaform/transforms` into your
+ * Vue compiler for the SSR-critical template transforms, and register
+ * the directive once per app with `installVRegister(app)` from
+ * `attaform/directive`.
  *
  * Zero-dep: the plugin imports nothing from `@rspack/core` (it taps the
  * resolve hook the compiler injects at the consumer's build).
@@ -39,6 +36,17 @@ import { W as WebpackFamilyPlugin, a as WebpackFamilyPluginOptions } from './sha
 type AttaformRspackPluginOptions = WebpackFamilyPluginOptions;
 /** The structural shape Rspack requires of the plugin. */
 type AttaformRspackPlugin = WebpackFamilyPlugin;
+/**
+ * Rspack plugin that resolves `attaform/zod` to the one adapter subpath
+ * matching the installed Zod major, so the build ships a single adapter
+ * instead of both.
+ *
+ * ```js
+ * import { attaform } from 'attaform/rspack'
+ *
+ * export default { plugins: [attaform()] }
+ * ```
+ */
 declare function attaform(options?: AttaformRspackPluginOptions): AttaformRspackPlugin;
 
 export { attaform };

package/dist/rspack.mjs

@@ -1,4 +1,4 @@
-import { c as createWebpackFamilyPlugin } from './shared/attaform.v0fQtWyA.mjs';
+import { c as createWebpackFamilyPlugin } from './shared/attaform.B1rH9ht6.mjs';
 
 function attaform(options = {}) {
   return createWebpackFamilyPlugin("attaform/rspack", options);

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)
 
@@ -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') {
@@ -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.D0x-qSXm.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.WiGdIqgx.mjs';
 
 var attaform_default = defineNuxtPlugin({
   // `enforce: 'pre'` makes the "we run before any component's setup" claim
@@ -11,8 +11,8 @@ var attaform_default = defineNuxtPlugin({
   setup(nuxtApp) {
     const isServer = import.meta.server;
     const config = useRuntimeConfig().public;
-    const { defaults, version } = config.attaform;
-    nuxtApp.vueApp.use(createAttaform({ ssr: isServer, defaults }));
+    const { version } = config.attaform;
+    nuxtApp.vueApp.use(createAttaform({ ssr: isServer }));
     nuxtApp.vueApp.provide(kAttaformWizardActiveStepResolver, (param) => {
       const value = useRoute().query[param];
       if (typeof value === "string") return value;

package/dist/shared/{attaform.CIWLMY-R.d.mts → attaform.2FslhB9R.d.mts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { G as GenericForm, s as FlatPath, B as NestedType, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, av as AcceptableDefaults, ah as ValidateOnConfig, a as UseFormReturnType } from './attaform.CsoeRi3P.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, s as FlatPath, B 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.Cvao8bW5.mjs → attaform.8mfKZCwH.mjs}

@@ -1,4 +1,4 @@
-import { m as mapSegmentKeys, f as pathsEqual, i as isPathPrefix } from './attaform.CZYt_5N_.mjs';
+import { m as mapSegmentKeys, f as pathsEqual, i as isPathPrefix } from './attaform.CdZIEf7_.mjs';
 
 const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
 const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
@@ -7,9 +7,8 @@ const ANONYMOUS_FORM_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon:`;
 const ANONYMOUS_WIZARD_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon-wizard:`;
 const DEFAULT_MAX_RECURSION_DEPTH = 64;
 function normalizeNumericOption(config) {
-  const { value, source, allowInfinity, min, defaultValue } = config;
-  if (allowInfinity && value === Infinity) return Infinity;
-  if (typeof value !== "number" || Number.isNaN(value) || value === Infinity || value === -Infinity) {
+  const { value, source, min, defaultValue } = config;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
     return defaultValue;
   }
   return Math.max(min, Math.floor(value));
@@ -22,7 +21,7 @@ function pickDefined(bag) {
   return out;
 }
 
-function callConsumerSchemaFn(fn, fallback, site) {
+function callConsumerFn(fn, fallback, site, detail) {
   try {
     return fn();
   } catch (err) {
@@ -77,8 +76,9 @@ function safeAssign(target, key, value) {
   }
   target[key] = value;
 }
+const SHADOWED_KEYS = new Set(Object.getOwnPropertyNames(Object.prototype));
 function isShadowedKey(key) {
-  return key in Object.prototype;
+  return SHADOWED_KEYS.has(key);
 }
 function safeOwnRead(target, key) {
   if (isShadowedKey(key)) {
@@ -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, consumerHas as d, safeOwnHas 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.BndjUUYX.mjs → attaform.B2iebkPA.mjs}

@@ -1,7 +1,7 @@
-import { a as InvalidUseFormConfigError } from './attaform.CZYt_5N_.mjs';
-import { u as useForm$2 } from './attaform.D1fnTifF.mjs';
-import { u as useForm$1 } from './attaform.C2MVyuxC.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform.B0dKL8ST.mjs';
+import { a as InvalidUseFormConfigError } from './attaform.CdZIEf7_.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;