attaform 0.29.0 → 0.30.1

package/dist/dev/shared/{attaform-dev.q6UutkCx.mjs → attaform-dev.CT7MDjPy.mjs}

@@ -1,7 +1,7 @@
-import { w as walkPathSegments, s as slimPrimitivesWalk, c as createAbstractSchema, b as buildFieldMetaPathMap, g as getFieldMetaForSchema, m as mergeDeep, f as fixStructuralDefaults, d as deriveDefaultWalk, a as getFieldMetaListForSchema } from './attaform-dev.BgM6FdtA.mjs';
-import { p as getAtPath, q as humanize, h as useAbstractForm } from './attaform-dev.DHuydLAC.mjs';
-import { c as callConsumerSchemaFn } from './attaform-dev.ButTkwHd.mjs';
-import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform-dev.A-TpJW0B.mjs';
+import { w as walkPathSegments, s as slimPrimitivesWalk, c as createAbstractSchema, a as createSharedSchemaStore, b as buildFieldMetaPathMap, g as getFieldMetaForSchema, f as fixStructuralDefaults, m as mergeDeep, d as deriveDefaultWalk, e as getFieldMetaListForSchema } from './attaform-dev.BUIFcTYf.mjs';
+import { h as getAtPath, j as humanize, c as useAbstractForm } from './attaform-dev.DxHdkkPG.mjs';
+import { c as callConsumerFn } from './attaform-dev.CZz4GYZ6.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform-dev.zlvDr0WB.mjs';
 
 function isZodSchemaType(schema, expectedType) {
   if (typeof schema !== "object" || schema === null) return false;
@@ -127,22 +127,29 @@ function getTupleItems(schema) {
   const def = readDef(schema);
   return def?.items ?? [];
 }
+function readOptionList(options) {
+  if (options === void 0) return [];
+  if (options instanceof Map) return [...options.values()];
+  return [...options];
+}
 function getUnionOptions(schema) {
-  const def = readDef(schema);
-  return def?.options ?? [];
+  return readOptionList(readDef(schema)?.options);
 }
 function getDiscriminatedOptions(schema) {
-  const def = readDef(schema);
-  return def?.options ?? [];
+  return readOptionList(readDef(schema)?.options);
 }
 function getDiscriminator(schema) {
   const def = readDef(schema);
   return def?.discriminator;
 }
 function getDiscriminatedOptionsMap(schema) {
-  const map = readDef(schema)?.optionsMap;
+  const def = readDef(schema);
+  const map = def?.optionsMap ?? def?.options;
   return map instanceof Map ? map : void 0;
 }
+function discriminatedOptionsAreMapped(schema) {
+  return readDef(schema)?.options instanceof Map;
+}
 function getIntersectionLeft(schema) {
   const def = readDef(schema);
   return def?.left;
@@ -299,11 +306,7 @@ function unwrapLazy(schema) {
   const def = readDef(schema);
   const getter = def?.getter;
   if (typeof getter !== "function") return void 0;
-  return callConsumerSchemaFn(() => getter(), void 0, "lazy-getter");
-}
-function getLazyGetter(schema) {
-  const def = readDef(schema);
-  return typeof def?.getter === "function" ? def.getter : void 0;
+  return callConsumerFn(() => getter(), void 0, "lazy-getter");
 }
 function getLiteralValues(schema) {
   const def = readDef(schema);
@@ -320,17 +323,13 @@ function getDefaultValue(schema) {
   const def = readDef(schema);
   const thunk = def?.defaultValue;
   if (typeof thunk !== "function") return void 0;
-  return callConsumerSchemaFn(() => thunk(), void 0, "default-factory");
+  return callConsumerFn(() => thunk(), void 0, "default-factory");
 }
 function getCatchDefault(schema) {
   const def = readDef(schema);
   const cv = def?.catchValue;
   if (typeof cv !== "function") return void 0;
-  return callConsumerSchemaFn(
-    () => cv({ error: null, input: void 0 }),
-    void 0,
-    "catch-factory"
-  );
+  return callConsumerFn(() => cv({ error: null, input: void 0 }), void 0, "catch-factory");
 }
 function hasCatchValue(schema) {
   const def = readDef(schema);
@@ -447,7 +446,6 @@ const V3_INTROSPECTOR = {
   // Walker accessors (D2 / D3 / D5).
   getArrayElement,
   getSetValueType,
-  getRecordKeyType,
   getRecordValueType,
   getMapKeyType: (schema) => kindOf(schema) === "map" ? getMapKeyType(schema) : void 0,
   getMapValueType: (schema) => kindOf(schema) === "map" ? getMapValueType(schema) : void 0,
@@ -465,7 +463,6 @@ const V3_INTROSPECTOR = {
   unwrapPipeIn,
   unwrapPipeOut,
   unwrapLazy,
-  getLazyGetter,
   getDefaultValue,
   getCatchDefault,
   hasCatchValue
@@ -601,22 +598,22 @@ function rebuildDiscriminatedUnion(original, options) {
       if (replacement !== void 0) optionsMap.set(value, replacement);
     }
   }
+  if (discriminatedOptionsAreMapped(original)) {
+    return rebuildWithDef(original, { options: optionsMap });
+  }
   return rebuildWithDef(original, { options, optionsMap });
 }
 function rebuildEffects(original, source, effect) {
   return rebuildWithDef(original, { schema: source, effect });
 }
 
-function stripAsyncChecks(schema) {
-  return walkEffects(schema, "strip");
-}
 function wrapAsyncSafeRefinements(schema) {
-  return walkEffects(schema, "wrap");
+  return walkEffects(schema);
 }
 function isThenable(value) {
   return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
 }
-function walkEffects(schema, policy) {
+function walkEffects(schema) {
   const seen = /* @__PURE__ */ new WeakSet();
   function recurse(s) {
     const candidate = s;
@@ -626,7 +623,6 @@ function walkEffects(schema, policy) {
     if (isZodSchemaType(s, "ZodEffects")) {
       const inner = unwrapEffectsSource(s);
       if (inner === void 0) return s;
-      if (policy === "strip") return recurse(inner);
       const effect = getEffect(s);
       const rebuiltInner = recurse(inner);
       const original = effect?.["refinement"];
@@ -800,18 +796,18 @@ function zodAdapter(zodSchema) {
       `[attaform/zod-v3] useForm schema root must be a ZodObject, ZodRecord, or ZodDiscriminatedUnion (got '${name}'). Wrap other shapes under a key.` 
     );
   }
-  return (formKey, options) => createAbstractSchema(
+  return (_formKey, options) => sharedV3Schemas(
     zodSchema,
-    V3_INTROSPECTOR,
-    buildV3Services(options.maxRecursionDepth),
-    formKey,
-    options
+    options.maxRecursionDepth,
+    () => createAbstractSchema(
+      zodSchema,
+      V3_INTROSPECTOR,
+      buildV3Services(options.maxRecursionDepth),
+      options
+    )
   );
 }
-async function lazyFingerprint(schema) {
-  const { fingerprintZodSchema } = await import('../chunks/fingerprint.mjs');
-  return fingerprintZodSchema(schema);
-}
+const sharedV3Schemas = createSharedSchemaStore();
 const syncSafeCache = /* @__PURE__ */ new WeakMap();
 function syncSafe(schema) {
   const cached = syncSafeCache.get(schema);
@@ -832,19 +828,14 @@ function buildV3Services(maxRecursionDepth) {
     return normalizeIssuePaths(issues, schema, data, maxRecursionDepth, peelAllV3Wrappers);
   };
   return {
-    fingerprint: (schema) => lazyFingerprint(schema),
     getNestedSchemasAtPath: (schema, path, maxRecursionDepth2) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth2),
-    // v3 pre-strips refinements / defaults / wrappers off the root for
-    // slim-mode walks — `getSlimPrimitiveTypesAtPath` and
-    // `getSchemasAtPath` both consume this variant so the yielded
-    // candidates reflect the slim shape.
-    // The slim-root projection is gone (size-teardown P7): the shared
-    // path walker peels wrappers / effects inline, so the slim and
-    // unstripped walks coincide — same aliasing v4 always had.
+    // The shared path walker peels wrappers and effects inline, so the
+    // slim and unstripped walks coincide and the root needs no slim
+    // projection of its own. Same aliasing v4 has.
     getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth2) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth2),
     slimPrimitivesOf: (schema, _maxRecursionDepth) => slimPrimitivesV3(schema),
-    deriveDefault: (schema, useDefault, _maxRecursionDepth, formKey) => getDefaultValuesFromZodSchema(schema, useDefault, formKey),
-    runStrictGetDefaults: (schema, config, formKey, maxRecursionDepth2) => runStrictGetDefaultsV3(schema, config, formKey, maxRecursionDepth2),
+    deriveDefault: (schema, useDefault) => getDefaultValuesFromZodSchema(schema, useDefault),
+    runGetDefaults: (schema, config, maxRecursionDepth2) => runGetDefaultsV3(schema, config, maxRecursionDepth2),
     unwrapStructuralWrappers: (schema) => unwrapStructuralLeafV3(schema),
     unwrapToDiscriminatedUnion: (schema) => unwrapToDiscriminatedUnion(schema),
     peelAllWrappers: (schema) => peelAllV3Wrappers(schema),
@@ -859,15 +850,14 @@ function buildV3Services(maxRecursionDepth) {
       const result = await schema.safeParseAsync(data);
       return result.success ? { success: true, data: result.data } : { success: false, issues: refileIssues(schema, data, result.error.issues) };
     },
-    // v3 returns the full recursive AbstractSchema for sub-schemas (the
-    // historical shape) — `getSchemasAtPath` consumers may probe any
-    // method on the result. The factory call rebuilds the full surface
-    // against the sub-schema with its own per-form caches.
-    makeSubSchema: (sub, formKey, maxRecursionDepth2) => createAbstractSchema(
+    // A `getSchemasAtPath` consumer may probe any method on the result,
+    // so a sub-schema comes back as a full recursive AbstractSchema: the
+    // factory call rebuilds the whole surface against it, with its own
+    // per-form caches.
+    makeSubSchema: (sub, maxRecursionDepth2) => createAbstractSchema(
       sub,
       V3_INTROSPECTOR,
       buildV3Services(maxRecursionDepth2),
-      formKey,
       { maxRecursionDepth: maxRecursionDepth2 }
     )
   };
@@ -889,17 +879,16 @@ function zodIssuesToValidationErrors(issues) {
     }
     validationErrors.push({
       message: issue.message,
-      // `ValidationError.path` is `(string | number)[]` per the
-      // public type. v3's `issue.path` is the same in the standard
-      // case, but a custom check via `ctx.addIssue({ path: [...] })`
-      // can smuggle a Symbol through — the public surface promised
-      // strings/numbers, so coerce defensively to keep the contract.
-      // Mirrors v4's behaviour at the same site.
+      // `ValidationError.path` is `(string | number)[]` publicly, and
+      // v3's `issue.path` matches in the standard case, but a custom
+      // check calling `ctx.addIssue({ path: [...] })` can smuggle a
+      // Symbol through. Coerce to keep the promise. v4 does the same
+      // here.
       //
-      // Adapter-side paths stay schema-relative — the validation
-      // pipeline in `create-form-store.ts` prepends the parent path
-      // to absolutise, then routes form-level (absolute path length 0)
-      // entries to the empty-string bucket at storage time.
+      // Adapter-side paths stay schema-RELATIVE: the validation pipeline
+      // in `core/create-form-store.ts` prepends the parent path to
+      // absolutise, then routes form-level entries, those whose absolute
+      // path is empty, to the empty-string bucket at storage time.
       path: coercePathSegments(issue.path),
       code
     });
@@ -931,10 +920,10 @@ function unwrapStructuralLeafV3(schema) {
   return current;
 }
 function isStructuralV3Kind(schema) {
-  return isZodSchemaType(schema, "ZodObject") || isZodSchemaType(schema, "ZodArray") || isZodSchemaType(schema, "ZodRecord") || isZodSchemaType(schema, "ZodTuple") || isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion") || // Wrappers that themselves resolve to a structural type — keep
-  // peeling at the next iteration.
-  isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodEffects") || // Newer transparent wrappers (v3.23+). Each wraps a single inner
-  // schema with no structural impact — `peelV3Wrappers` resolves them.
+  return isZodSchemaType(schema, "ZodObject") || isZodSchemaType(schema, "ZodArray") || isZodSchemaType(schema, "ZodRecord") || isZodSchemaType(schema, "ZodTuple") || isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion") || // Wrappers that themselves resolve to a structural type; keep
+  // peeling next iteration.
+  isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodEffects") || // Newer transparent wrappers (v3.23+), each wrapping one inner
+  // schema with no structural impact. `peelV3Wrappers` resolves them.
   isZodSchemaType(schema, "ZodPipeline") || isZodSchemaType(schema, "ZodReadonly") || isZodSchemaType(schema, "ZodBranded");
 }
 function peelV3Wrappers(schema) {
@@ -1086,16 +1075,8 @@ function peelAllV3Wrappers(schema) {
   }
   return current;
 }
-function getDefaultValuesFromZodSchema(formSchema, useDefaultSchemaValues, formKey) {
-  return deriveDefaultWalk(formSchema, useDefaultSchemaValues, V3_INTROSPECTOR, 64, {
-    unsupportedKindFallback: (schema) => {
-      const kindName = schema.constructor?.name ?? "unknown";
-      console.warn(
-        `[attaform] zod-v3 adapter: unsupported schema kind '${kindName}' on form '${formKey}'. Defaulting the field to null. Use a supported zod kind (object/array/record/string/number/etc.) at this path.` 
-      );
-      return null;
-    }
-  });
+function getDefaultValuesFromZodSchema(formSchema, useDefaultSchemaValues) {
+  return deriveDefaultWalk(formSchema, useDefaultSchemaValues, V3_INTROSPECTOR, 64);
 }
 function resolveFieldMetaAtPathV3(rootSchema, path, maxRecursionDepth) {
   const lastSegment = path.length === 0 ? "" : path[path.length - 1];
@@ -1126,92 +1107,51 @@ function resolveFieldMetaAtPathV3(rootSchema, path, maxRecursionDepth) {
     meta: Object.freeze({ ...payload ?? {} })
   };
 }
-function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth) {
+function runGetDefaultsV3(rootSchema, config, maxRecursionDepth) {
   const defaultValuesWithoutConstraints = getDefaultValuesFromZodSchema(
     rootSchema,
-    config.useDefaultSchemaValues,
-    formKey
+    config.useDefaultSchemaValues
   );
-  const rawDefaultValues = mergeDeep(defaultValuesWithoutConstraints, config.constraints);
-  if ((config.strict ?? true) !== false) {
-    if (containsAsyncTransform(rootSchema)) {
-      return {
-        data: rawDefaultValues,
-        errors: void 0,
-        success: true,
-        formKey
-      };
-    }
-    try {
-      const strictResult = syncSafe(rootSchema).safeParse(rawDefaultValues);
-      if (strictResult.success) {
-        return {
-          data: rawDefaultValues,
-          errors: void 0,
-          success: true,
-          formKey
-        };
-      }
-      return {
-        data: rawDefaultValues,
-        errors: zodIssuesToValidationErrors(strictResult.error.issues),
-        success: false,
-        formKey
-      };
-    } catch (err) {
-      const isAsyncDetect = err instanceof Error && err.message.includes("Async refinement encountered");
-      if (isAsyncDetect) {
-        try {
-          const strippedResult = syncSafe(stripAsyncChecks(rootSchema)).safeParse(rawDefaultValues);
-          if (strippedResult.success) {
-            return {
-              data: rawDefaultValues,
-              errors: void 0,
-              success: true,
-              formKey
-            };
-          }
-          return {
-            data: rawDefaultValues,
-            errors: zodIssuesToValidationErrors(strippedResult.error.issues),
-            success: false,
-            formKey
-          };
-        } catch {
-          return {
-            data: rawDefaultValues,
-            errors: void 0,
-            success: true,
-            formKey
-          };
-        }
-      }
-      return {
-        data: rawDefaultValues,
-        errors: void 0,
-        success: true,
-        formKey
-      };
-    }
-  }
-  const fixed = fixStructuralDefaults(
+  const rawDefaultValues = config.constraints === void 0 ? defaultValuesWithoutConstraints : fixStructuralDefaults(
     rootSchema,
-    rawDefaultValues,
+    mergeDeep(defaultValuesWithoutConstraints, config.constraints),
     config.useDefaultSchemaValues,
     maxRecursionDepth,
     {
       intro: V3_INTROSPECTOR,
       slimPrimitivesOf: (s) => slimPrimitivesV3(s),
-      deriveDefault: (s, useDefault) => getDefaultValuesFromZodSchema(s, useDefault, formKey),
+      deriveDefault: (s, useDefault) => getDefaultValuesFromZodSchema(s, useDefault),
       unwrapToDiscriminatedUnion: (s) => unwrapToDiscriminatedUnion(s)
     }
-  );
-  return {
-    data: fixed.data,
-    errors: void 0,
-    success: true,
-    formKey
-  };
+  ).data;
+  if (containsAsyncTransform(rootSchema)) {
+    return {
+      data: rawDefaultValues,
+      errors: void 0,
+      success: true
+    };
+  }
+  try {
+    const parseResult = syncSafe(rootSchema).safeParse(rawDefaultValues);
+    if (parseResult.success) {
+      return {
+        data: rawDefaultValues,
+        errors: void 0,
+        success: true
+      };
+    }
+    return {
+      data: rawDefaultValues,
+      errors: zodIssuesToValidationErrors(parseResult.error.issues),
+      success: false
+    };
+  } catch {
+    return {
+      data: rawDefaultValues,
+      errors: void 0,
+      success: true
+    };
+  }
 }
 
 function useForm(configuration) {

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

@@ -1,4 +1,4 @@
-import { m as mapSegmentKeys, f as pathsEqual, i as isPathPrefix } from './attaform-dev.A-TpJW0B.mjs';
+import { m as mapSegmentKeys, f as pathsEqual, i as isPathPrefix } from './attaform-dev.zlvDr0WB.mjs';
 
 const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
 const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
@@ -7,13 +7,11 @@ 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)) {
     {
-      const acceptedDescription = allowInfinity ? "a non-negative integer or Infinity" : "a non-negative finite integer";
       console.warn(
-        `[attaform] ${source} must be ${acceptedDescription}; got ${String(value)}. Falling back to ${String(defaultValue)}.`
+        `[attaform] ${source} must be a non-negative finite integer; got ${String(value)}. Falling back to ${String(defaultValue)}.`
       );
     }
     return defaultValue;
@@ -29,20 +27,32 @@ function pickDefined(bag) {
 }
 
 const reported = /* @__PURE__ */ new Set() ;
-function report(site, err) {
-  if (reported === null || reported.has(site)) return;
-  reported.add(site);
-  const advice = site === "default-factory" ? "a `.default(() => ...)` factory threw. Attaform used `undefined` for that field's initial value." : site === "catch-factory" ? "a `.catch(() => ...)` fallback threw. Attaform used `undefined` for that value." : "a `z.lazy(() => ...)` factory threw. Attaform stopped descending at that node, so paths below it will not resolve.";
+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} A function inside your schema must not throw; wrap your own try/catch if the failure is recoverable. Original 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 callConsumerSchemaFn(fn, fallback, site) {
+function callConsumerFn(fn, fallback, site, detail) {
   try {
     return fn();
   } catch (err) {
-    report(site, err);
+    reportConsumerThrow(site, detail, err);
     return fallback;
   }
 }
@@ -94,8 +104,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)) {
@@ -372,4 +383,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, reportConsumerThrow as t, ANONYMOUS_WIZARD_KEY_PREFIX as u };

package/dist/dev/shared/{attaform-dev.DD5m2W51.mjs → attaform-dev.Chm4D6SJ.mjs}

@@ -1,4 +1,4 @@
-import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform-dev.A-TpJW0B.mjs';
+import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform-dev.zlvDr0WB.mjs';
 import { shallowReactive, getCurrentInstance, inject } from 'vue';
 
 function detectSSR(options = {}) {
@@ -17,7 +17,6 @@ const kFormContext = /* @__PURE__ */ Symbol.for("attaform:form-context");
 const kFormInstanceId = /* @__PURE__ */ Symbol.for("attaform:form-instance-id");
 function createRegistry(options = {}) {
   const ssr = detectSSR(options);
-  const defaults = Object.freeze({ ...options.defaults ?? {} });
   const forms = shallowReactive(/* @__PURE__ */ new Map());
   const wizards = shallowReactive(/* @__PURE__ */ new Map());
   const pendingHydration = shallowReactive(/* @__PURE__ */ new Map());
@@ -102,7 +101,6 @@ function createRegistry(options = {}) {
     wizards,
     pendingHydration,
     ssr,
-    defaults,
     trackConsumer,
     trackWizardConsumer,
     enqueuePrefetch,
@@ -201,7 +199,7 @@ function hydrateAttaformState(app, payload) {
         got = "v" in payload ? payload.v : void 0;
       }
       console.warn(
-        `[attaform] hydrateAttaformState: payload version mismatch (expected ${ATTAFORM_STATE_VERSION}, got ${String(got)}). Skipping hydration \u2014 forms will construct fresh. This usually means the SSR bundle is on a different attaform version than the client (rolling deploy / stale cache).`
+        `[attaform] hydrateAttaformState: payload version mismatch (expected ${ATTAFORM_STATE_VERSION}, got ${String(got)}). Skipping hydration; forms will construct fresh. This usually means the SSR bundle is on a different attaform version than the client (rolling deploy / stale cache).`
       );
     }
     return;

package/dist/dev/shared/{attaform-dev.DrzObAZo.mjs → attaform-dev.DuEE4GU1.mjs}

@@ -1,7 +1,7 @@
-import { a as InvalidUseFormConfigError } from './attaform-dev.A-TpJW0B.mjs';
-import { u as useForm$2 } from './attaform-dev.q6UutkCx.mjs';
-import { u as useForm$1 } from './attaform-dev.BO-71R54.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform-dev.BgM6FdtA.mjs';
+import { a as InvalidUseFormConfigError } from './attaform-dev.zlvDr0WB.mjs';
+import { u as useForm$2 } from './attaform-dev.CT7MDjPy.mjs';
+import { u as useForm$1 } from './attaform-dev.BJK1kqHY.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform-dev.BUIFcTYf.mjs';
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;