attaform 0.31.0 → 0.31.1

package/dist/index.d.mts

@@ -1,55 +1,15 @@
-export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, A as AttaformRegistry, C as CompiledStep, D as DEVTOOLS_WINDOW_KEY, F as FormStatus, f as FormStatusSeed, G as GateMarker, I as InjectWizardInput, g as InvalidPathError, h as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, i as ReservedFormKeyError, S as SerializedAttaformState, j as SerializedFormData, k as StepSlot, l as SubmitErrorHandlerError, U as UseRegisterOptions, m as UseRegisterReturn, n as UseWizardReturnType, W as WizardAggregateError, o as WizardCtx, p as WizardCtxForm, q as WizardOnError, r as WizardOnSubmit, s as WizardOptions, t as WizardPersistFn, u as WizardRestoreFn, v as WizardRestoreState, w as WizardStatusesProxy, x as WizardSubmitContext, y as assignKey, z as createAttaform, B as createRegistry, E as escapeForInlineScript, H as gate, J as getRegistryFromApp, K as hydrateAttaformState, M as injectForm, N as injectWizard, P as isRegisterValue, Q as kAttaformRegistry, T as lazy, V as renderAttaformState, X as useRegister, Y as useRegistry, Z as useWizard } from './shared/attaform.DAo0QBmS.mjs';
-import { G as GenericForm, F as FormKey, U as UseFormConfiguration, ap as AcceptableDefaults, ab as ValidateOnConfig, a as UseFormReturnType, D as DefaultValuesInput, h as FieldMetaPayload } from './shared/attaform.DZnrDrNb.mjs';
+export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, A as AttaformRegistry, C as CompiledStep, D as DEVTOOLS_WINDOW_KEY, F as FormStatus, f as FormStatusSeed, G as GateMarker, I as InjectWizardInput, g as InvalidPathError, h as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, i as ReservedFormKeyError, S as SerializedAttaformState, j as SerializedFormData, k as StepSlot, l as SubmitErrorHandlerError, U as UseRegisterOptions, m as UseRegisterReturn, n as UseWizardReturnType, W as WizardAggregateError, o as WizardCtx, p as WizardCtxForm, q as WizardOnError, r as WizardOnSubmit, s as WizardOptions, t as WizardPersistFn, u as WizardRestoreFn, v as WizardRestoreState, w as WizardStatusesProxy, x as WizardSubmitContext, y as assignKey, z as createAttaform, B as createRegistry, E as escapeForInlineScript, H as gate, J as getRegistryFromApp, K as hydrateAttaformState, M as injectForm, N as injectWizard, P as isRegisterValue, Q as kAttaformRegistry, T as lazy, V as renderAttaformState, X as useRegister, Y as useRegistry, Z as useWizard } from './shared/attaform.CYlF4P6X.mjs';
+import { G as GenericForm, F as FormKey, U as UseFormConfiguration, ap as AcceptableDefaults, ab as ValidateOnConfig, a as UseFormReturnType, D as DefaultValuesInput, h as FieldMetaPayload } from './shared/attaform.i13OEHJF.mjs';
 import { AbstractSchema } from './abstract.mjs';
-export { b as ArrayItem, c as ArrayPath, C as CustomDirectiveRegisterAssignerFn, d as DeepPartial, e as DefaultValuesShape, f as DisplayState, E as ErrorInput, g as ErrorsProxyShape, i as FieldState, j as FieldStateMap, k as FieldStateMapEntry, l as FlatPath, m as FormErrorRecord, n as FormErrorsSurface, o as FormMeta, H as HandleSubmit, p as HistoryPlugin, I as IsTuple, q as IsUnion, J as JoinSegments, r as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, s as NestedType, O as OnError, t as OnSubmit, P as ParseOptions, u as PartialFlatPath, v as Path, w as PathKey, x as PendingValidationStatus, y as Primitive, R as ROOT_PATH, z as ROOT_PATH_KEY, B as ReactiveValidationStatus, Q as RecordPath, S as RecordValue, T as RegisterDirective, V as RegisterFlatPath, W as RegisterOptions, X as RegisterSelectModifier, Y as RegisterTextModifier, Z as RegisterTransform, _ as RegisterValue, $ as SchemaParseErrorWithData, a0 as SchemaParseErrorWithoutData, a1 as SchemaParseResult, a2 as SchemaParseSuccess, a3 as Segment, a4 as SetValueCallback, a5 as SetValuePayload, a6 as SettledValidationStatus, a7 as SlimPrimitiveKind, a8 as SubmitHandler, a9 as Unset, aa as ValidateOn, ac as ValidationError, ad as ValidationResponse, ae as ValidationResponseWithoutValue, af as ValueOfUnion, ag as WriteMeta, ah as WriteShape, ai as canonicalizePath, aj as isPathPrefix, ak as isUnset, al as parseDottedPath, am as unset } from './shared/attaform.DZnrDrNb.mjs';
-export { v as vRegister } from './shared/attaform.D9RqPgGu.mjs';
-import { S as SupportedRootSchema, b as StorageShape } from './shared/attaform.CRVe8s82.mjs';
-export { P as PathInput, a as PathOutput } from './shared/attaform.CRVe8s82.mjs';
+export { b as ArrayItem, c as ArrayPath, C as CustomDirectiveRegisterAssignerFn, d as DeepPartial, e as DefaultValuesShape, f as DisplayState, E as ErrorInput, g as ErrorsProxyShape, i as FieldState, j as FieldStateMap, k as FieldStateMapEntry, l as FlatPath, m as FormErrorRecord, n as FormErrorsSurface, o as FormMeta, H as HandleSubmit, p as HistoryPlugin, I as IsTuple, q as IsUnion, J as JoinSegments, r as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, s as NestedType, O as OnError, t as OnSubmit, P as ParseOptions, u as PartialFlatPath, v as Path, w as PathKey, x as PendingValidationStatus, y as Primitive, R as ROOT_PATH, z as ROOT_PATH_KEY, B as ReactiveValidationStatus, Q as RecordPath, S as RecordValue, T as RegisterDirective, V as RegisterFlatPath, W as RegisterOptions, X as RegisterSelectModifier, Y as RegisterTextModifier, Z as RegisterTransform, _ as RegisterValue, $ as SchemaParseErrorWithData, a0 as SchemaParseErrorWithoutData, a1 as SchemaParseResult, a2 as SchemaParseSuccess, a3 as Segment, a4 as SetValueCallback, a5 as SetValuePayload, a6 as SettledValidationStatus, a7 as SlimPrimitiveKind, a8 as SubmitHandler, a9 as Unset, aa as ValidateOn, ac as ValidationError, ad as ValidationResponse, ae as ValidationResponseWithoutValue, af as ValueOfUnion, ag as WriteMeta, ah as WriteShape, ai as canonicalizePath, aj as isPathPrefix, ak as isUnset, al as parseDottedPath, am as unset } from './shared/attaform.i13OEHJF.mjs';
+export { v as vRegister } from './shared/attaform.DZOynI6c.mjs';
+import { S as SupportedRootSchema, b as StorageShape } from './shared/attaform.B9PYKlhB.mjs';
+export { P as PathInput, a as PathOutput } from './shared/attaform.B9PYKlhB.mjs';
 import { S as SupportedRootSchema$1, a as StorageShape$1 } from './shared/attaform.B-Tb62qV.mjs';
 import { UnwrapZodRoot } from './zod-v3.mjs';
 import { z } from 'zod';
 import 'vue';
 
-/**
- * Type-level Zod-major discriminator for the unified `attaform/zod`
- * entry. The runtime dispatch (`use-form.ts`'s impl) already routes on
- * the schema's shape via `isZodV4SchemaShape`; this is the type-level
- * mirror so the overloads and projection helpers discriminate the same
- * way.
- *
- * Why a structural marker instead of `z.ZodObject`: the unified entry's
- * overloads constrain on `z.ZodObject`, but the published `.d.mts`
- * resolves `z` against whichever single Zod major the consumer
- * installed. In a v3-only install `z.ZodObject` is v3's `ZodObject`
- * (and, lacking its required type arguments, degrades to an `any`-like
- * error type under `skipLibCheck`), so a v3 schema satisfies the v4
- * overload's constraint and binds it, collapsing the read slot to
- * `never`. A Zod v4 schema carries the `_zod` internals brand; a v3
- * schema never does.
- * Intersecting a v4-only constraint or conditional branch with this
- * marker keeps it unreachable for a v3 schema regardless of how `zod`
- * resolves, so v3 schemas fall through to the v3 overload.
- *
- * Distinct from `core/zod-shape.ts`'s runtime `ZodV4Shape` (which reads
- * the public `def` getter): at the type level the stable v4 brand is
- * `_zod.def`, the same internals `StorageShape` (v4) already reads.
- *
- * Pairing requirement: a v4 overload/branch must constrain on
- * `z.ZodObject<z.ZodRawShape> & ZodV4Internals`, NOT bare
- * `z.ZodObject & ZodV4Internals`. In a v3-only install `z.ZodObject`
- * with no type argument is `ZodObject<T, ...>` missing its required
- * arguments, an error type that behaves like `any` under
- * `skipLibCheck`, so `any & ZodV4Internals` collapses back to `any` and
- * the marker stops excluding v3 schemas. Supplying `z.ZodRawShape`
- * keeps it a concrete object type in both majors, so the intersection
- * stays meaningful.
- */
-type ZodV4Internals = {
-    _zod: {
-        def: unknown;
-    };
-};
-
 /**
  * Per-major projection helpers shared by the unified `attaform/zod`
  * entry. Each maps an arbitrary Zod v4 OR v3 object schema to the
@@ -101,12 +61,13 @@ type V3ReadOf<S extends SupportedRootSchema$1> = StorageShape$1<UnwrapZodRoot<S>
  * const form = useForm({ schema })
  * ```
  *
- * The constraint intersects `ZodV4Internals`, the v4-only `_zod` brand,
- * so a v3 schema cannot bind this overload even where `z` resolves to v3
- * in a single-major install; it falls through to the v3 overload below.
- * See `types-zod-major.ts`.
+ * The constraint is structural on Zod's core `_zod` internals. A
+ * `zod/mini` schema binds it as its classic twin does, and a v3 schema,
+ * which carries no `_zod`, cannot bind it even where `zod` resolves to v3
+ * in a single-major install, so it falls through to the v3 overload
+ * below. See `SupportedRootSchema` in `../zod-v4/types-root.ts`.
  */
-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'> & {
+declare function useForm<Schema extends SupportedRootSchema, 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>;
@@ -158,11 +119,11 @@ declare function useForm<Schema extends SupportedRootSchema$1, K extends FormKey
  * cleanly under a generic constraint because no conditional
  * is present.
  */
-type UseFormReturnV4<Schema extends z.ZodObject, K extends FormKey = FormKey> = UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K>;
+type UseFormReturnV4<Schema extends SupportedRootSchema, K extends FormKey = FormKey> = UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K>;
 /**
  * Direct V4 configuration projection. Mirrors `UseFormReturnV4`.
  */
-type UseFormConfigV4<Schema extends z.ZodObject, K extends FormKey = FormKey> = Omit<UseFormConfiguration<V4FormOf<Schema>, V4OutOf<Schema>, AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>, DefaultValuesInput<V4FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
+type UseFormConfigV4<Schema extends SupportedRootSchema, K extends FormKey = FormKey> = Omit<UseFormConfiguration<V4FormOf<Schema>, V4OutOf<Schema>, AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>, DefaultValuesInput<V4FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
     schema: Schema;
 } & ValidateOnConfig;
 /**
@@ -190,13 +151,13 @@ type UseFormConfigV3<Schema extends z.ZodObject<z.ZodRawShape>, K extends FormKe
  * under a generic constraint, so this helper's dispatch stays deferred
  * and return-type compatibility cannot be proven.
  */
-type UseFormReturn<Schema, K extends FormKey = FormKey> = Schema extends SupportedRootSchema & ZodV4Internals ? UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K> : Schema extends SupportedRootSchema$1 ? UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K> : never;
+type UseFormReturn<Schema, K extends FormKey = FormKey> = Schema extends SupportedRootSchema ? UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K> : Schema extends SupportedRootSchema$1 ? UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K> : never;
 /**
  * The configuration parameter shape of `useForm` for a given Zod
  * schema. Same dispatch as `UseFormReturn`; it replaces
  * `Parameters<typeof useForm<Schema, K>>[0]` in test code.
  */
-type UseFormConfig<Schema, K extends FormKey = FormKey> = Schema extends SupportedRootSchema & ZodV4Internals ? Omit<UseFormConfiguration<V4FormOf<Schema>, V4OutOf<Schema>, AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>, DefaultValuesInput<V4FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
+type UseFormConfig<Schema, K extends FormKey = FormKey> = Schema extends SupportedRootSchema ? Omit<UseFormConfiguration<V4FormOf<Schema>, V4OutOf<Schema>, AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>, DefaultValuesInput<V4FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
     schema: Schema;
 } & ValidateOnConfig : Schema extends SupportedRootSchema$1 ? Omit<UseFormConfiguration<V3FormOf<Schema>, V3OutOf<Schema>, AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>, DefaultValuesInput<V3FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
     schema: Schema;

package/dist/index.mjs

@@ -1,6 +1,6 @@
-export { A as AttaformError, I as InvalidPathError, a as InvalidUseFormConfigError, O as OutsideSetupError, R as ROOT_PATH, b as ROOT_PATH_KEY, c as RegistryNotInstalledError, d as ReservedFormKeyError, S as SubmitErrorHandlerError, e as canonicalizePath, i as isPathPrefix, p as parseDottedPath } from './shared/attaform.CdZIEf7_.mjs';
-export { A as AttaformErrorCode, e as escapeForInlineScript, g as gate, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, d as useRegister, f as useWizard } from './shared/attaform.DNPJPOO7.mjs';
-export { D as DEVTOOLS_WINDOW_KEY, c as createAttaform, a as createRegistry, g as getRegistryFromApp, h as hydrateAttaformState, k as kAttaformRegistry, r as renderAttaformState, u as useRegistry } from './shared/attaform.C4shmwyJ.mjs';
-export { a as assignKey, v as vRegister } from './shared/attaform.DxKQsqFZ.mjs';
-export { f as fieldMeta, u as useForm, w as withMeta } from './shared/attaform.L011tHgJ.mjs';
+export { A as AttaformError, I as InvalidPathError, a as InvalidUseFormConfigError, O as OutsideSetupError, R as ROOT_PATH, b as ROOT_PATH_KEY, c as RegistryNotInstalledError, d as ReservedFormKeyError, S as SubmitErrorHandlerError, e as canonicalizePath, i as isPathPrefix, p as parseDottedPath } from './shared/attaform.BhtAZysa.mjs';
+export { A as AttaformErrorCode, e as escapeForInlineScript, g as gate, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, d as useRegister, f as useWizard } from './shared/attaform.DAf4ehIe.mjs';
+export { D as DEVTOOLS_WINDOW_KEY, c as createAttaform, a as createRegistry, g as getRegistryFromApp, h as hydrateAttaformState, k as kAttaformRegistry, r as renderAttaformState, u as useRegistry } from './shared/attaform.CdA9bfRv.mjs';
+export { a as assignKey, v as vRegister } from './shared/attaform.BPMOl562.mjs';
+export { f as fieldMeta, u as useForm, w as withMeta } from './shared/attaform.KEfNRDot.mjs';
 export { i as isRegisterValue } from './shared/attaform.KvlEedlF.mjs';

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.C4shmwyJ.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.CdA9bfRv.mjs';
 
 var attaform_default = defineNuxtPlugin({
   // `enforce: 'pre'` makes the "we run before any component's setup" claim

package/dist/shared/{attaform.BWUn8Kjy.mjs → attaform.B5b-HmhH.mjs}

@@ -1,7 +1,7 @@
-import { j as humanize, c as useAbstractForm } from './attaform.DNPJPOO7.mjs';
-import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.CdZIEf7_.mjs';
-import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, a as createSharedSchemaStore, b as buildFieldMetaPathMap, e as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform.DL2nl_QR.mjs';
-import { c as callConsumerFn } from './attaform.8mfKZCwH.mjs';
+import { j as humanize, c as useAbstractForm } from './attaform.DAf4ehIe.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.BhtAZysa.mjs';
+import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, a as createSharedSchemaStore, b as buildFieldMetaPathMap, e as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform.j9xI_ObC.mjs';
+import { d as callConsumerFn } from './attaform._1Zp3mDG.mjs';
 
 function readDef(schema) {
   if (schema === null || typeof schema !== "object") return void 0;
@@ -179,6 +179,9 @@ function getDiscriminatedOptions(schema) {
   return Array.isArray(options) ? options : [];
 }
 function assertZodVersion(schema) {
+  assertZodV4Node(schema);
+}
+function assertZodV4Node(schema) {
   const def = readDef(schema);
   if (def?.type === void 0) {
     throw new Error(
@@ -237,7 +240,7 @@ function walkCapabilities(node, capabilities, visited) {
   if (def === void 0) return;
   const checks = getChecks(node);
   if (checks.some(isAsyncCheck)) capabilities.asyncRefine = true;
-  if (checks.length > 0 && CONTAINER_SLOTS.some((key) => def[key] !== void 0)) {
+  if (checks.some(isVerdictCheck) && CONTAINER_SLOTS.some((key) => def[key] !== void 0)) {
     capabilities.containerOrRootRefine = true;
   }
   if (typeof def.transform === "function" && def.transform.constructor.name === "AsyncFunction") {
@@ -259,6 +262,11 @@ function walkCapabilities(node, capabilities, visited) {
     }
   }
 }
+function isVerdictCheck(check) {
+  if (typeof check !== "object" || check === null) return true;
+  const kind = check._zod?.def?.check;
+  return kind !== "describe" && kind !== "meta";
+}
 function isAsyncCheck(check) {
   if (typeof check !== "object" || check === null) return false;
   const c = check;
@@ -315,9 +323,9 @@ function zodIssuesToValidationErrors(issues) {
 
 const V4_INTROSPECTOR = {
   kindOf: (schema) => kindOf(schema),
-  getObjectShape: (schema) => getObjectShape(schema),
+  getObjectShape,
   getTupleItems,
-  getDiscriminatedOptions: (schema) => getDiscriminatedOptions(schema),
+  getDiscriminatedOptions,
   getDiscriminator,
   getLiteralValues,
   isPreprocessNode,
@@ -481,7 +489,7 @@ function isLeafRequired(schema, depth = 0) {
   return true;
 }
 function zodV4Adapter(rootSchema) {
-  assertZodVersion(rootSchema);
+  assertZodV4Node(rootSchema);
   assertKeyedRoot(rootSchema);
   return (_formKey, options) => sharedV4Schemas(
     rootSchema,
@@ -602,7 +610,8 @@ function resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth) {
   };
 }
 function readDescription(schema) {
-  const candidate = schema.description;
+  const scope = globalThis;
+  const candidate = scope.__zod_globalRegistry?.get(schema)?.description ?? schema.description;
   return typeof candidate === "string" ? candidate : void 0;
 }
 

package/dist/shared/{attaform.CRVe8s82.d.mts → attaform.B9PYKlhB.d.mts}

@@ -1,6 +1,23 @@
 import { z } from 'zod';
-import { G as GenericForm, l as FlatPath, s as NestedType, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, ap as AcceptableDefaults, ab as ValidateOnConfig, a as UseFormReturnType } from './attaform.DZnrDrNb.mjs';
+import { G as GenericForm, l as FlatPath, s as NestedType, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, ap as AcceptableDefaults, ab as ValidateOnConfig, a as UseFormReturnType } from './attaform.i13OEHJF.mjs';
 
+/**
+ * A Zod v4 schema whose core definition matches `Def`, named by the
+ * `_zod` internals that classic `zod` and `zod/mini` schemas both carry.
+ */
+type ZodV4SchemaOf<Def> = {
+    _zod: {
+        def: Def;
+    };
+};
+/**
+ * Any Zod v4 schema, from `zod` or `zod/mini`. The public signatures that
+ * take a v4 schema below the root (`PathInput`, `PathOutput`, `withMeta`)
+ * constrain on it, for the reasons `SupportedRootSchema` gives.
+ */
+type ZodV4Schema = ZodV4SchemaOf<{
+    type: string;
+}>;
 /**
  * The Zod v4 schema roots `useForm` accepts. A fixed-shape
  * `z.object({ … })` is the common case; `z.record(K, V)` admits a
@@ -16,22 +33,29 @@ import { G as GenericForm, l as FlatPath, s as NestedType, F as FormKey, U as Us
  * `z.map` / `z.set`) are not form roots; wrap them under a key. The
  * adapter's runtime construction rejects them with a legible error.
  *
- * `z.ZodObject` MUST keep its `z.ZodRawShape` argument, and the
- * discriminated-union arm MUST stay fully applied. The unified entry's
- * v4 overload constrains on `SupportedRootSchema & ZodV4Internals` to
- * keep v3 schemas out (see `../unified/types-zod-major.ts`). In a
- * single-major (v3-only) consumer install, the published `.d.mts`
- * resolves this `z` to v3, where a bare or under-applied Zod class is
- * missing its required arguments and degrades to an `any`-like error
- * type; `any` then absorbs the union and `any & ZodV4Internals`
- * collapses back to `any`, so the marker stops excluding v3 schemas and
- * the read slot poisons to `never`. `z.ZodRecord` carries defaults for
- * both arguments, so it stays concrete in either major.
- * `z.ZodDiscriminatedUnion` does NOT (v3 requires both arguments, and
- * its parameter order is the reverse of v4's), so the arm is written
- * fully applied; the v3-only bundled-types fixture guards it.
+ * Each arm is structural on `_zod.def.type`, Zod's core internals, so a
+ * `zod/mini` root binds exactly as its classic twin does, and the form
+ * types project through `z.input` / `z.output`, which are core's too. A
+ * plain union's `def` has no `discriminator`, which keeps it out of the
+ * third arm.
+ *
+ * The alias names nothing from `zod`, and the unified `attaform/zod`
+ * entry depends on that. Its published `.d.mts` resolves `zod` against
+ * the one major a consumer installed, and in a v3-only install a classic
+ * class reference such as `z.ZodObject` degrades to an `any`-like error
+ * type, which a v3 schema satisfies: the v4 overload would capture it and
+ * collapse its read slot to `never`. No v3 schema carries `_zod`, so this
+ * constraint sends every v3 schema to the v3 overload however `zod`
+ * resolves. The v3-only bundled-types fixture guards it.
  */
-type SupportedRootSchema = z.ZodObject<z.ZodRawShape> | z.ZodRecord | z.ZodDiscriminatedUnion<readonly z.ZodObject<z.ZodRawShape>[], string>;
+type SupportedRootSchema = ZodV4SchemaOf<{
+    type: 'object';
+}> | ZodV4SchemaOf<{
+    type: 'record';
+}> | ZodV4SchemaOf<{
+    type: 'union';
+    discriminator: string;
+}>;
 
 /**
  * The shape `form.values.<key>` returns at runtime. Four cases per leaf:
@@ -164,7 +188,7 @@ type StorageLeaf<L> = InputIsUnknown<L> extends true ? unknown : L extends {
  * type FlagWriteIn = PathInput<typeof schema, 'flag'> // string
  * ```
  */
-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 PathInput<Schema extends ZodV4Schema, Path extends string> = z.input<Schema> extends GenericForm ? Path extends FlatPath<z.input<Schema>> ? NestedType<z.input<Schema>, Path> : never : never;
 /**
  * What `Path` holds after the full parse pipeline: the schema's
  * `z.output<Schema>` shape there. It matches `form.parse()`'s `data` and
@@ -177,7 +201,7 @@ type PathInput<Schema extends z.ZodType, Path extends string> = z.input<Schema>
  * type FlagParsedOut = PathOutput<typeof schema, 'flag'> // boolean
  * ```
  */
-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;
+type PathOutput<Schema extends ZodV4Schema, 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
@@ -217,4 +241,4 @@ declare function useForm<Schema extends SupportedRootSchema, K extends FormKey =
 } & ValidateOnConfig): UseFormReturnType<FormOf<Schema>, OutOf<Schema>, ReadOf<Schema>, K>;
 
 export { useForm as u };
-export type { PathInput as P, SupportedRootSchema as S, PathOutput as a, StorageShape as b };
+export type { PathInput as P, SupportedRootSchema as S, ZodV4Schema as Z, PathOutput as a, StorageShape as b };

package/dist/shared/{attaform.DxKQsqFZ.mjs → attaform.BPMOl562.mjs}

@@ -1,6 +1,7 @@
 import { toRaw, reactive, markRaw, effectScope, watch, nextTick } from 'vue';
 import { i as isRegisterValue, a as isTransforming, S as SSR_COMPONENT_HOST_MODIFIER, R as REGISTER_OWNER_MARKER, b as V_REGISTER_MARKER } from './attaform.KvlEedlF.mjs';
-import { e as canonicalizePath } from './attaform.CdZIEf7_.mjs';
+import { e as canonicalizePath } from './attaform.BhtAZysa.mjs';
+import { e as safeOwnHas } from './attaform._1Zp3mDG.mjs';
 
 function activeElementOf(node) {
   const rootNode = node.getRootNode();
@@ -304,7 +305,7 @@ function createHostChannel() {
       return commit(rv, value, modifiers);
     },
     writeInput(rv, payload, modifiers) {
-      if (typeof payload !== "object" || payload === null || payload instanceof Event || !("value" in payload) || !Object.hasOwn(payload, "value")) {
+      if (typeof payload !== "object" || payload === null || payload instanceof Event || !("value" in payload) || !safeOwnHas(payload, "value")) {
         return false;
       }
       return rv.setValueFromHost(payload.value, modifiers);

package/dist/{dev/shared/attaform-dev.CZz4GYZ6.mjs → shared/attaform.BPSqtU7a.mjs}

@@ -1,4 +1,5 @@
-import { m as mapSegmentKeys, f as pathsEqual, i as isPathPrefix } from './attaform-dev.zlvDr0WB.mjs';
+import { s as safeAssign, a as safeOwnRead, r as readConsumerIndex, c as consumerKeys, b as readConsumerProp } from './attaform._1Zp3mDG.mjs';
+import { m as mapSegmentKeys, f as pathsEqual, i as isPathPrefix } from './attaform.BhtAZysa.mjs';
 
 const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
 const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
@@ -9,11 +10,6 @@ const DEFAULT_MAX_RECURSION_DEPTH = 64;
 function normalizeNumericOption(config) {
   const { value, source, min, defaultValue } = config;
   if (typeof value !== "number" || !Number.isFinite(value)) {
-    {
-      console.warn(
-        `[attaform] ${source} must be a non-negative finite integer; got ${String(value)}. Falling back to ${String(defaultValue)}.`
-      );
-    }
     return defaultValue;
   }
   return Math.max(min, Math.floor(value));
@@ -26,124 +22,6 @@ function pickDefined(bag) {
   return out;
 }
 
-const reported = /* @__PURE__ */ new Set() ;
-function reportConsumerThrow(site, detail, err) {
-  const key = detail === void 0 ? site : `${site}|${detail}`;
-  if (reported === null || reported.has(key)) return;
-  reported.add(key);
-  const at = detail === void 0 ? "" : ` at \`${detail}\``;
-  const advice = {
-    "default-factory": "a `.default(() => ...)` factory threw. Attaform used `undefined` for that field's initial value.",
-    "catch-factory": "a `.catch(() => ...)` fallback threw. Attaform used `undefined` for that value.",
-    "lazy-getter": "a `z.lazy(() => ...)` factory threw. Attaform stopped descending at that node, so paths below it will not resolve.",
-    "wizard-slot": `a function step slot threw${at}. Attaform dropped that step from the compiled list; the rest of the flow still navigates.`,
-    "wizard-lazy-slot": `a \`lazy()\` step resolver threw${at}. Attaform dropped that step from the compiled list until the resolver's own dependencies change.`,
-    "wizard-progress": "a `useWizard({ progress })` override threw. Attaform fell back to its own valid-step ratio.",
-    "wizard-restore": "a `useWizard({ restore })` callback threw. Attaform read no step from it, so the wizard stays where it is.",
-    "wizard-persist": "a `useWizard({ persist })` callback threw. Attaform navigated anyway, so the step is live but unrecorded.",
-    "wizard-default-statuses": "a `useWizard({ defaultStatuses })` factory threw or rejected. Attaform seeded no statuses, the same as omitting the option."
-  };
-  console.error(
-    `[attaform] ${advice[site]} Attaform has nowhere to surface this, so it must not throw; wrap your own try/catch if the failure is recoverable. Original error:`,
-    err
-  );
-}
-function callConsumerFn(fn, fallback, site, detail) {
-  try {
-    return fn();
-  } catch (err) {
-    reportConsumerThrow(site, detail, err);
-    return fallback;
-  }
-}
-function readConsumerProp(obj, key) {
-  try {
-    return obj[key];
-  } catch {
-    return void 0;
-  }
-}
-function consumerKeys(obj) {
-  try {
-    return Object.keys(obj);
-  } catch {
-    return [];
-  }
-}
-function readConsumerIndex(arr, i) {
-  try {
-    return arr[i];
-  } catch {
-    return void 0;
-  }
-}
-function consumerSymbolKeys(obj) {
-  try {
-    return Object.getOwnPropertySymbols(obj);
-  } catch {
-    return [];
-  }
-}
-function consumerHas(obj, key) {
-  try {
-    return key in obj;
-  } catch {
-    return false;
-  }
-}
-
-function safeAssign(target, key, value) {
-  if (key === "__proto__") {
-    Object.defineProperty(target, key, {
-      value,
-      writable: true,
-      enumerable: true,
-      configurable: true
-    });
-    return;
-  }
-  target[key] = value;
-}
-const SHADOWED_KEYS = new Set(Object.getOwnPropertyNames(Object.prototype));
-function isShadowedKey(key) {
-  return SHADOWED_KEYS.has(key);
-}
-function safeOwnRead(target, key) {
-  if (isShadowedKey(key)) {
-    const desc = Object.getOwnPropertyDescriptor(target, key);
-    if (desc === void 0) return void 0;
-    return "value" in desc ? desc.value : readConsumerProp(target, key);
-  }
-  return readConsumerProp(target, key);
-}
-function safeOwnHas(target, key) {
-  try {
-    return Object.prototype.hasOwnProperty.call(target, key);
-  } catch {
-    return false;
-  }
-}
-function spreadConsumerRecord(src) {
-  try {
-    return { ...src };
-  } catch {
-    const out = {};
-    for (const key of Object.keys(src)) {
-      safeAssign(out, key, readConsumerProp(src, key));
-    }
-    return out;
-  }
-}
-function copyConsumerArray(src) {
-  try {
-    return src.slice();
-  } catch {
-    const out = new Array(src.length);
-    for (let i = 0; i < src.length; i++) out[i] = readConsumerIndex(src, i);
-    return out;
-  }
-}
-
 function isDescendable(value) {
   if (value === null || typeof value !== "object") return false;
   if (Array.isArray(value)) return true;
@@ -151,6 +29,9 @@ function isDescendable(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === null || proto === Object.prototype;
 }
+function isBarePatch(patch) {
+  return patch.kind === "added" ? isDescendable(patch.newValue) : patch.kind === "removed" && isDescendable(patch.oldValue);
+}
 function appendSegment(prefix, segment) {
   const next = new Array(prefix.length + 1);
   for (let i = 0; i < prefix.length; i++) {
@@ -165,11 +46,11 @@ function diffAndApply(oldValue, newValue, prefix, visit) {
   const oldIsDescendable = isDescendable(oldValue);
   const newIsDescendable = isDescendable(newValue);
   if (oldValue === void 0 && newIsDescendable) {
-    walkNewDescendable(newValue, prefix, visit);
+    walkDescendable(newValue, prefix, visit, true);
     return;
   }
   if (oldIsDescendable && newValue === void 0) {
-    walkOldDescendable(oldValue, prefix, visit);
+    walkDescendable(oldValue, prefix, visit, false);
     return;
   }
   if (oldIsDescendable && newIsDescendable) {
@@ -219,50 +100,51 @@ function diffAndApply(oldValue, newValue, prefix, visit) {
   }
   visit({ kind: "changed", path: prefix, oldValue, newValue });
 }
-function walkNewDescendable(newValue, prefix, visit) {
-  if (Array.isArray(newValue)) {
-    for (let i = 0; i < newValue.length; i++) {
-      diffAndApply(void 0, readConsumerIndex(newValue, i), appendSegment(prefix, i), visit);
+function walkDescendable(value, prefix, visit, arrived) {
+  let reported = false;
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      diffSlot(readConsumerIndex(value, i), appendSegment(prefix, i), visit, arrived);
     }
-  } else if (newValue instanceof Map) {
-    for (const [key, entry] of newValue) {
-      diffAndApply(void 0, entry, appendSegment(prefix, key), visit);
+    reported = value.length > 0;
+  } else if (value instanceof Map) {
+    for (const [key, entry] of value) {
+      diffSlot(entry, appendSegment(prefix, key), visit, arrived);
     }
+    reported = value.size > 0;
   } else {
-    const rec = newValue;
+    const rec = value;
     for (const k of consumerKeys(rec)) {
-      diffAndApply(void 0, readConsumerProp(rec, k), appendSegment(prefix, k), visit);
+      const entry = readConsumerProp(rec, k);
+      if (entry === void 0) continue;
+      reported = true;
+      if (arrived) diffAndApply(void 0, entry, appendSegment(prefix, k), visit);
+      else diffAndApply(entry, void 0, appendSegment(prefix, k), visit);
     }
   }
+  if (!reported) visit(presencePatch(arrived, prefix, value));
 }
-function walkOldDescendable(oldValue, prefix, visit) {
-  if (Array.isArray(oldValue)) {
-    for (let i = 0; i < oldValue.length; i++) {
-      diffAndApply(readConsumerIndex(oldValue, i), void 0, appendSegment(prefix, i), visit);
-    }
-  } else if (oldValue instanceof Map) {
-    for (const [key, entry] of oldValue) {
-      diffAndApply(entry, void 0, appendSegment(prefix, key), visit);
-    }
-  } else {
-    const rec = oldValue;
-    for (const k of consumerKeys(rec)) {
-      diffAndApply(readConsumerProp(rec, k), void 0, appendSegment(prefix, k), visit);
-    }
-  }
+function diffSlot(entry, path, visit, arrived) {
+  if (entry === void 0) visit(presencePatch(arrived, path, entry));
+  else if (arrived) diffAndApply(void 0, entry, path, visit);
+  else diffAndApply(entry, void 0, path, visit);
+}
+function presencePatch(arrived, path, value) {
+  return arrived ? { kind: "added", path, newValue: value } : { kind: "removed", path, oldValue: value };
 }
 function diffMapsLockstep(oldMap, newMap, prefix, visit) {
   for (const [key, entry] of newMap) {
-    diffAndApply(oldMap.get(key), entry, appendSegment(prefix, key), visit);
+    const path = appendSegment(prefix, key);
+    if (oldMap.has(key)) diffAndApply(oldMap.get(key), entry, path, visit);
+    else diffSlot(entry, path, visit, true);
   }
   for (const [key, entry] of oldMap) {
-    if (newMap.has(key)) continue;
-    diffAndApply(entry, void 0, appendSegment(prefix, key), visit);
+    if (!newMap.has(key)) diffSlot(entry, appendSegment(prefix, key), visit, false);
   }
 }
 function diffArraysLockstep(oldArr, newArr, prefix, visit) {
-  const max = Math.max(oldArr.length, newArr.length);
-  for (let i = 0; i < max; i++) {
+  const min = Math.min(oldArr.length, newArr.length);
+  for (let i = 0; i < min; i++) {
     diffAndApply(
       readConsumerIndex(oldArr, i),
       readConsumerIndex(newArr, i),
@@ -270,6 +152,12 @@ function diffArraysLockstep(oldArr, newArr, prefix, visit) {
       visit
     );
   }
+  for (let i = min; i < newArr.length; i++) {
+    diffSlot(readConsumerIndex(newArr, i), appendSegment(prefix, i), visit, true);
+  }
+  for (let i = min; i < oldArr.length; i++) {
+    diffSlot(readConsumerIndex(oldArr, i), appendSegment(prefix, i), visit, false);
+  }
 }
 function diffObjectsLockstep(oldRec, newRec, prefix, visit) {
   const seen = /* @__PURE__ */ new Set();
@@ -383,4 +271,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, 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, reportConsumerThrow as t, ANONYMOUS_WIZARD_KEY_PREFIX as u };
+export { ANONYMOUS_FORM_KEY_PREFIX as A, DEFAULT_HISTORY_MAX_SNAPSHOTS as D, RESERVED_KEY_PREFIX as R, DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS as a, isDescendable as b, applyChangedKeys as c, diffAndApply as d, DEFAULT_MAX_RECURSION_DEPTH as e, ANONYMOUS_WIZARD_KEY_PREFIX as f, isBarePatch as i, normalizeNumericOption as n, pickDefined as p, structuralSnapshot as s };

package/dist/shared/{attaform.CdZIEf7_.mjs → attaform.BhtAZysa.mjs}

@@ -114,7 +114,8 @@ const canonicalStringCache = /* @__PURE__ */ new Map();
 const PATHKEY_TO_SEGMENTS_MAX = 4096;
 const pathKeyToSegments = /* @__PURE__ */ new Map();
 function rememberSegmentsForPathKey(key, segments) {
-  if (!pathKeyToSegments.has(key) && pathKeyToSegments.size >= PATHKEY_TO_SEGMENTS_MAX) {
+  if (pathKeyToSegments.has(key)) return;
+  if (pathKeyToSegments.size >= PATHKEY_TO_SEGMENTS_MAX) {
     const oldest = pathKeyToSegments.keys().next().value;
     if (oldest !== void 0) pathKeyToSegments.delete(oldest);
   }
@@ -156,7 +157,7 @@ function canonicalizePath(input) {
   return keyForSegments(input);
 }
 function keyForSegments(input) {
-  const segments = Array.from(input).map(normalizeSegment);
+  const segments = input.map(normalizeSegment);
   const key = JSON.stringify(segments);
   rememberSegmentsForPathKey(key, segments);
   return { segments, key };