attaform 0.27.6 → 0.29.0

package/dist/abstract.d.mts

@@ -1,7 +1,8 @@
-import { A as AttaformRegistry } from './shared/attaform.CHlJLAiv.mjs';
-export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, C as CompiledStep, D as DEFAULT_TIMINGS, f as DEVTOOLS_WINDOW_KEY, g as DisplayTimings, F as FormStatus, h as FormStatusSeed, G as GateMarker, I as InjectWizardInput, i as InvalidPathError, j as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, k as ReservedFormKeyError, S as SerializedAttaformState, l as SerializedFormData, m as StepSlot, n as SubmitErrorHandlerError, U as UseRegisterReturn, o as UseWizardReturnType, W as WizardAggregateError, p as WizardCtx, q as WizardCtxForm, r as WizardOnError, s as WizardOnSubmit, t as WizardOptions, u as WizardPersistFn, v as WizardRestoreFn, w as WizardRestoreState, x as WizardStatusesProxy, y as WizardSubmitContext, z as assignKey, B as createAttaform, E as createRegistry, H as defaultCoercionRules, J as defaultDisplayState, K as defineCoercion, M as escapeForInlineScript, N as gate, P as getRegistryFromApp, Q as hydrateAttaformState, T as injectForm, V as injectWizard, X as isRegisterValue, Y as kAttaformRegistry, Z as lazy, _ as makeDefaultDisplayState, $ as renderAttaformState, a0 as useRegister, a1 as useRegistry, a2 as useWizard, a3 as vRegister } from './shared/attaform.CHlJLAiv.mjs';
-import { G as GenericForm, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, D as DefaultValuesInput, a as UseFormReturnType } from './shared/attaform.DniawQLP.mjs';
-export { b as ArrayItem, c as ArrayPath, d as AttaformDefaults, C as CoercionEntry, e as CoercionRegistry, f as CoercionResult, g as CustomDirectiveRegisterAssignerFn, h as DeepPartial, i as DefaultValuesResponse, j as DefaultValuesShape, k as DisplayCtx, l as DisplayMachine, m as DisplayState, E as ErrorInput, n as ErrorsProxyShape, o as FieldMetaPayload, p as FieldState, q as FieldStateMap, r as FieldStateMapEntry, s as FlatPath, t as FormErrorRecord, u as FormErrorsSurface, v as FormMeta, w as GetDisplayState, H as HandleSubmit, x as HistoryConfig, I as IsTuple, y as IsUnion, J as JoinSegments, z as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, B as NestedType, O as OnError, P as OnInvalidSubmitPolicy, Q as OnSubmit, R as PartialFlatPath, S as Path, T as PathKey, V as PendingValidationStatus, W as Primitive, X as ROOT_PATH, Y as ROOT_PATH_KEY, Z as ReactiveValidationStatus, _ as RegisterDirective, $ as RegisterFlatPath, a0 as RegisterOptions, a1 as RegisterSelectModifier, a2 as RegisterTextModifier, a3 as RegisterTransform, a4 as RegisterValue, a5 as Segment, a6 as SetValueCallback, a7 as SetValuePayload, a8 as SettledValidationStatus, a9 as SlimPrimitiveKind, aa as SlimRuntimeOf, ab as SubmitHandler, ac as Unset, ad as ValidateOn, ae as ValidateOnConfig, af as ValidationError, ag as ValidationResponse, ah as ValidationResponseWithoutValue, ai as ValueOfUnion, aj as WriteMeta, ak as WriteShape, al as canonicalizePath, am as isPathPrefix, an as isUnset, ao as parseDottedPath, ap as unset } from './shared/attaform.DniawQLP.mjs';
+import { A as AttaformRegistry } from './shared/attaform.DDtqHYv1.mjs';
+export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, C as CompiledStep, D as DEFAULT_TIMINGS, f as DEVTOOLS_WINDOW_KEY, g as DisplayTimings, F as FormStatus, h as FormStatusSeed, G as GateMarker, I as InjectWizardInput, i as InvalidPathError, j as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, k as ReservedFormKeyError, S as SerializedAttaformState, l as SerializedFormData, m as StepSlot, n as SubmitErrorHandlerError, U as UseRegisterOptions, o as UseRegisterReturn, p as UseWizardReturnType, W as WizardAggregateError, q as WizardCtx, r as WizardCtxForm, s as WizardOnError, t as WizardOnSubmit, u as WizardOptions, v as WizardPersistFn, w as WizardRestoreFn, x as WizardRestoreState, y as WizardStatusesProxy, z as WizardSubmitContext, B as assignKey, E as createAttaform, H as createRegistry, J as defaultCoercionRules, K as defaultDisplayState, M as defineCoercion, N as escapeForInlineScript, P as gate, Q as getRegistryFromApp, T as hydrateAttaformState, V as injectForm, X as injectWizard, Y as isRegisterValue, Z as kAttaformRegistry, _ as lazy, $ as makeDefaultDisplayState, a0 as renderAttaformState, a1 as useRegister, a2 as useRegistry, a3 as useWizard } from './shared/attaform.DDtqHYv1.mjs';
+import { G as GenericForm, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, D as DefaultValuesInput, a as UseFormReturnType } from './shared/attaform.CsoeRi3P.mjs';
+export { b as ArrayItem, c as ArrayPath, d as AttaformDefaults, C as CoercionEntry, e as CoercionRegistry, f as CoercionResult, g as CustomDirectiveRegisterAssignerFn, h as DeepPartial, i as DefaultValuesResponse, j as DefaultValuesShape, k as DisplayCtx, l as DisplayMachine, m as DisplayState, E as ErrorInput, n as ErrorsProxyShape, o as FieldMetaPayload, p as FieldState, q as FieldStateMap, r as FieldStateMapEntry, s as FlatPath, t as FormErrorRecord, u as FormErrorsSurface, v as FormMeta, w as GetDisplayState, H as HandleSubmit, x as HistoryPlugin, I as IsTuple, y as IsUnion, J as JoinSegments, z as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, B as NestedType, O as OnError, P as OnInvalidSubmitPolicy, Q as OnSubmit, R as ParseOptions, S as PartialFlatPath, T as Path, V as PathKey, W as PendingValidationStatus, X as Primitive, Y as ROOT_PATH, Z as ROOT_PATH_KEY, _ as ReactiveValidationStatus, $ as RecordPath, a0 as RecordValue, a1 as RegisterDirective, a2 as RegisterFlatPath, a3 as RegisterOptions, a4 as RegisterSelectModifier, a5 as RegisterTextModifier, a6 as RegisterTransform, a7 as RegisterValue, a8 as Segment, a9 as SetValueCallback, aa as SetValuePayload, ab as SettledValidationStatus, ac as SlimPrimitiveKind, ad as SlimRuntimeOf, ae as SubmitHandler, af as Unset, ag as ValidateOn, ah as ValidateOnConfig, ai as ValidationError, aj as ValidationResponse, ak as ValidationResponseWithoutValue, al as ValueOfUnion, am as WriteMeta, an as WriteShape, ao as canonicalizePath, ap as isPathPrefix, aq as isUnset, ar as parseDottedPath, as as unset } from './shared/attaform.CsoeRi3P.mjs';
+export { v as vRegister } from './shared/attaform.axHXVQO7.mjs';
 import 'vue';
 
 /**

package/dist/abstract.mjs

@@ -1,4 +1,5 @@
-export { A as AttaformErrorCode, D as DEFAULT_TIMINGS, d as defaultCoercionRules, a as defaultDisplayState, b as defineCoercion, e as escapeForInlineScript, g as gate, i as injectForm, c as injectWizard, f as isUnset, l as lazy, m as makeDefaultDisplayState, u as unset, h as useAbstractForm, j as useRegister, k as useWizard } from './shared/attaform.CKH2lGdL.mjs';
-export { A as AttaformError, D as DEVTOOLS_WINDOW_KEY, 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 assignKey, f as canonicalizePath, g as createAttaform, h as createRegistry, i as getRegistryFromApp, j as hydrateAttaformState, k as isPathPrefix, l as kAttaformRegistry, p as parseDottedPath, r as renderAttaformState, u as useRegistry, v as vRegister } from './shared/attaform.nMaz2C5P.mjs';
+export { A as AttaformErrorCode, D as DEFAULT_TIMINGS, d as defaultCoercionRules, a as defaultDisplayState, b as defineCoercion, e as escapeForInlineScript, g as gate, i as injectForm, c as injectWizard, f as isUnset, l as lazy, m as makeDefaultDisplayState, u as unset, h as useAbstractForm, j as useRegister, k as useWizard } from './shared/attaform.CZMAYwSK.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.CZYt_5N_.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.D0x-qSXm.mjs';
+export { a as assignKey, v as vRegister } from './shared/attaform.DffRL5pP.mjs';
 export { i as isRegisterValue } from './shared/attaform.KvlEedlF.mjs';
-//# sourceMappingURL=abstract.mjs.map

package/dist/chunks/fingerprint.mjs

@@ -1,4 +1,4 @@
-import { c as canonicalStringify } from '../shared/attaform.BJGA_UOS.mjs';
+import { c as canonicalStringify } from '../shared/attaform.BxfsuwBR.mjs';
 
 const cyclicSentinel = "<cyclic>";
 function fingerprintZodSchema(schema) {
@@ -181,4 +181,3 @@ function formatChecks(checks) {
 }
 
 export { fingerprintZodSchema };
-//# sourceMappingURL=fingerprint.mjs.map

package/dist/chunks/fingerprint2.mjs

@@ -1,5 +1,5 @@
-import { c as canonicalStringify } from '../shared/attaform.BJGA_UOS.mjs';
-import { k as kindOf, g as getIntersectionLeft, b as getIntersectionRight, c as unwrapLazy, d as unwrapInner, e as unwrapPipe, h as getDiscriminator, i as getDiscriminatedOptions, j as getUnionOptions, l as getRecordKeyType, m as getRecordValueType, n as getTupleItems, o as getSetValueType, p as getArrayElement, q as getObjectShape, r as getEnumValues, s as getLiteralValues, t as getChecks, v as getCatchDefault, x as getDefaultValue } from '../shared/attaform.DMxM2kol.mjs';
+import { c as canonicalStringify } from '../shared/attaform.BxfsuwBR.mjs';
+import { k as kindOf, g as getIntersectionLeft, b as getIntersectionRight, c as unwrapLazy, d as unwrapInner, e as unwrapPipe, f as getDiscriminator, h as getDiscriminatedOptions, i as getUnionOptions, j as getRecordKeyType, l as getRecordValueType, m as getTupleItems, n as getSetValueType, o as getArrayElement, p as getObjectShape, q as getEnumValues, r as getLiteralValues, s as getChecks, t as getCatchDefault, v as getDefaultValue } from '../shared/attaform.C2MVyuxC.mjs';
 
 const cyclicSentinel = "<cyclic>";
 function fingerprintZodSchema(schema) {
@@ -157,4 +157,3 @@ function compare(a, b) {
 }
 
 export { fingerprintZodSchema };
-//# sourceMappingURL=fingerprint2.mjs.map

package/dist/dev/abstract.mjs

@@ -0,0 +1,4 @@
+export { A as AttaformErrorCode, D as DEFAULT_TIMINGS, d as defaultCoercionRules, a as defaultDisplayState, b as defineCoercion, e as escapeForInlineScript, g as gate, i as injectForm, c as injectWizard, f as isUnset, l as lazy, m as makeDefaultDisplayState, u as unset, h as useAbstractForm, j as useRegister, k as useWizard } from './shared/attaform-dev.DHuydLAC.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-dev.A-TpJW0B.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-dev.DD5m2W51.mjs';
+export { a as assignKey, i as isRegisterValue, v as vRegister } from './shared/attaform-dev.D8aoKb89.mjs';

package/dist/{chunks → dev/chunks}/dev-key-collision-warnings.mjs

@@ -20,4 +20,3 @@ async function warnOnSchemaFingerprintMismatch(key, existing, incoming) {
 }
 
 export { warnOnSchemaFingerprintMismatch };
-//# sourceMappingURL=dev-key-collision-warnings.mjs.map

package/dist/{chunks → dev/chunks}/devtools.mjs

@@ -1,4 +1,4 @@
-import { f as canonicalizePath } from '../shared/attaform.nMaz2C5P.mjs';
+import { e as canonicalizePath } from '../shared/attaform-dev.A-TpJW0B.mjs';
 
 const INSPECTOR_ID = "attaform";
 const TIMELINE_LAYER_ID = "attaform:events";
@@ -114,15 +114,15 @@ function wire(api, app, registry) {
       }
     ];
     payload.state["Schema Errors"] = [
-      ...[...state.schemaErrors.entries()].map(([k, v]) => ({
+      ...[...state.errorCells.entries()].filter(([, cell]) => cell.schema.length > 0).map(([k, cell]) => ({
         key: String(k),
-        value: v
+        value: cell.schema
       }))
     ];
     payload.state["User Errors"] = [
-      ...[...state.userErrors.entries()].map(([k, v]) => ({
+      ...[...state.errorCells.entries()].filter(([, cell]) => cell.user.length > 0).map(([k, cell]) => ({
         key: String(k),
-        value: v
+        value: cell.user
       }))
     ];
     payload.state["Aggregates"] = [
@@ -152,4 +152,3 @@ function wire(api, app, registry) {
 }
 
 export { setupAttaformDevtools };
-//# sourceMappingURL=devtools.mjs.map

package/dist/{chunks/fingerprint.cjs → dev/chunks/fingerprint.mjs}

@@ -1,6 +1,4 @@
-'use strict';
-
-const canonicalStringify = require('../shared/attaform.CQN9R62B.cjs');
+import { c as canonicalStringify } from '../shared/attaform-dev.BxfsuwBR.mjs';
 
 const cyclicSentinel = "<cyclic>";
 function fingerprintZodSchema(schema) {
@@ -45,7 +43,7 @@ function computeFingerprint(schema, cache, inProgress) {
     case "ZodNever":
       return kind;
     case "ZodLiteral":
-      return `ZodLiteral:${canonicalStringify.canonicalStringify(def.value)}`;
+      return `ZodLiteral:${canonicalStringify(def.value)}`;
     case "ZodEnum": {
       const values = Array.isArray(def.values) ? def.values : [];
       const sorted = [...values].sort((a, b) => {
@@ -53,7 +51,7 @@ function computeFingerprint(schema, cache, inProgress) {
         const bs = String(b);
         return as < bs ? -1 : as > bs ? 1 : 0;
       });
-      return `ZodEnum:${canonicalStringify.canonicalStringify(sorted)}`;
+      return `ZodEnum:${canonicalStringify(sorted)}`;
     }
     case "ZodNativeEnum": {
       const values = def.values && typeof def.values === "object" && !Array.isArray(def.values) ? Object.values(def.values) : [];
@@ -62,7 +60,7 @@ function computeFingerprint(schema, cache, inProgress) {
         const bs = String(b);
         return as < bs ? -1 : as > bs ? 1 : 0;
       });
-      return `ZodNativeEnum:${canonicalStringify.canonicalStringify(sorted)}`;
+      return `ZodNativeEnum:${canonicalStringify(sorted)}`;
     }
     case "ZodObject": {
       const shape = readShapeSafely(def);
@@ -174,13 +172,12 @@ function defaultFactoryRepr(factory) {
   }
   if (!Object.is(first, second)) return "fn:*";
   if (typeof first === "function") return "fn:*";
-  return canonicalStringify.canonicalStringify(first);
+  return canonicalStringify(first);
 }
 function formatChecks(checks) {
   if (!Array.isArray(checks) || checks.length === 0) return "";
-  const parts = checks.map((c) => canonicalStringify.canonicalStringify(c)).sort();
+  const parts = checks.map((c) => canonicalStringify(c)).sort();
   return `[${parts.join(";")}]`;
 }
 
-exports.fingerprintZodSchema = fingerprintZodSchema;
-//# sourceMappingURL=fingerprint.cjs.map
+export { fingerprintZodSchema };

package/dist/{chunks/fingerprint2.cjs → dev/chunks/fingerprint2.mjs}

@@ -1,7 +1,5 @@
-'use strict';
-
-const canonicalStringify = require('../shared/attaform.CQN9R62B.cjs');
-const index = require('../shared/attaform.DdQN7sgN.cjs');
+import { c as canonicalStringify } from '../shared/attaform-dev.BxfsuwBR.mjs';
+import { k as kindOf, g as getIntersectionLeft, b as getIntersectionRight, c as unwrapLazy, d as unwrapInner, e as unwrapPipe, f as getDiscriminator, h as getDiscriminatedOptions, i as getUnionOptions, j as getRecordKeyType, l as getRecordValueType, m as getTupleItems, n as getSetValueType, o as getArrayElement, p as getObjectShape, q as getEnumValues, r as getLiteralValues, s as getChecks, t as getCatchDefault, v as getDefaultValue } from '../shared/attaform-dev.BO-71R54.mjs';
 
 const cyclicSentinel = "<cyclic>";
 function fingerprintZodSchema(schema) {
@@ -23,7 +21,7 @@ function visit(schema, cache, inProgress) {
   }
 }
 function computeFingerprint(schema, cache, inProgress) {
-  const kind = index.kindOf(schema);
+  const kind = kindOf(schema);
   const recurse = (child) => visit(child, cache, inProgress);
   switch (kind) {
     // Kind-only leaves: no further structure to descend into.
@@ -45,68 +43,68 @@ function computeFingerprint(schema, cache, inProgress) {
     case "date":
       return `${kind}${formatChecks(schema)}`;
     case "literal": {
-      const values = [...index.getLiteralValues(schema)].sort((a, b) => {
-        const as = canonicalStringify.canonicalStringify(a);
-        const bs = canonicalStringify.canonicalStringify(b);
+      const values = [...getLiteralValues(schema)].sort((a, b) => {
+        const as = canonicalStringify(a);
+        const bs = canonicalStringify(b);
         return as < bs ? -1 : as > bs ? 1 : 0;
       });
-      return `literal:${canonicalStringify.canonicalStringify(values)}`;
+      return `literal:${canonicalStringify(values)}`;
     }
     case "enum":
-      return `enum:${canonicalStringify.canonicalStringify([...index.getEnumValues(schema)].sort((a, b) => compare(a, b)))}`;
+      return `enum:${canonicalStringify([...getEnumValues(schema)].sort((a, b) => compare(a, b)))}`;
     case "object": {
-      const shape = index.getObjectShape(schema);
+      const shape = getObjectShape(schema);
       const sortedEntries = Object.entries(shape).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${recurse(v)}`);
       return `object{${sortedEntries.join(",")}}${formatChecks(schema)}`;
     }
     case "array":
-      return `array[${recurse(index.getArrayElement(schema))}]${formatChecks(schema)}`;
+      return `array[${recurse(getArrayElement(schema))}]${formatChecks(schema)}`;
     case "set":
-      return `set<${recurse(index.getSetValueType(schema))}>${formatChecks(schema)}`;
+      return `set<${recurse(getSetValueType(schema))}>${formatChecks(schema)}`;
     case "tuple":
-      return `tuple[${index.getTupleItems(schema).map(recurse).join(",")}]`;
+      return `tuple[${getTupleItems(schema).map(recurse).join(",")}]`;
     case "record":
-      return `record<${recurse(index.getRecordKeyType(schema))},${recurse(index.getRecordValueType(schema))}>`;
+      return `record<${recurse(getRecordKeyType(schema))},${recurse(getRecordValueType(schema))}>`;
     case "union": {
-      const options = index.getUnionOptions(schema).map(recurse).sort();
+      const options = getUnionOptions(schema).map(recurse).sort();
       return `union(${options.join("|")})`;
     }
     case "discriminated-union": {
-      const disc = index.getDiscriminator(schema) ?? "?";
-      const options = index.getDiscriminatedOptions(schema).map(recurse).sort();
+      const disc = getDiscriminator(schema) ?? "?";
+      const options = getDiscriminatedOptions(schema).map(recurse).sort();
       return `dunion[${JSON.stringify(disc)}](${options.join("|")})`;
     }
     case "optional": {
-      const inner = index.unwrapInner(schema);
+      const inner = unwrapInner(schema);
       return inner === void 0 ? "optional(?)" : `optional(${recurse(inner)})`;
     }
     case "nullable": {
-      const inner = index.unwrapInner(schema);
+      const inner = unwrapInner(schema);
       return inner === void 0 ? "nullable(?)" : `nullable(${recurse(inner)})`;
     }
     case "default": {
-      const inner = index.unwrapInner(schema);
-      return `default[${stableValueRepr(index.getDefaultValue, schema)}](${inner === void 0 ? "?" : recurse(inner)})`;
+      const inner = unwrapInner(schema);
+      return `default[${stableValueRepr(getDefaultValue, schema)}](${inner === void 0 ? "?" : recurse(inner)})`;
     }
     case "readonly": {
-      const inner = index.unwrapInner(schema);
+      const inner = unwrapInner(schema);
       return inner === void 0 ? "readonly(?)" : `readonly(${recurse(inner)})`;
     }
     case "pipe": {
-      const inner = index.unwrapPipe(schema);
+      const inner = unwrapPipe(schema);
       return inner === void 0 ? "pipe(?)" : `pipe(${recurse(inner)})`;
     }
     case "catch": {
-      const inner = index.unwrapInner(schema);
-      return `catch[${stableValueRepr(index.getCatchDefault, schema)}](${inner === void 0 ? "?" : recurse(inner)})`;
+      const inner = unwrapInner(schema);
+      return `catch[${stableValueRepr(getCatchDefault, schema)}](${inner === void 0 ? "?" : recurse(inner)})`;
     }
     case "lazy": {
-      const inner = index.unwrapLazy(schema);
+      const inner = unwrapLazy(schema);
       return inner === void 0 ? "lazy(?)" : `lazy(${recurse(inner)})`;
     }
     case "intersection": {
-      const left = index.getIntersectionLeft(schema);
-      const right = index.getIntersectionRight(schema);
+      const left = getIntersectionLeft(schema);
+      const right = getIntersectionRight(schema);
       const leftFp = left === void 0 ? "?" : recurse(left);
       const rightFp = right === void 0 ? "?" : recurse(right);
       const parts = [leftFp, rightFp].sort();
@@ -137,10 +135,10 @@ function stableValueRepr(get, schema) {
   const first = get(schema);
   const second = get(schema);
   if (!Object.is(first, second) || typeof first === "function") return "fn:*";
-  return canonicalStringify.canonicalStringify(first);
+  return canonicalStringify(first);
 }
 function formatChecks(schema) {
-  const checks = index.getChecks(schema);
+  const checks = getChecks(schema);
   if (checks.length === 0) return "";
   const parts = checks.map((c) => serializeCheck(c)).sort();
   return `[${parts.join(";")}]`;
@@ -148,9 +146,9 @@ function formatChecks(schema) {
 function serializeCheck(check) {
   if (check !== null && typeof check === "object") {
     const def = check._zod?.def;
-    if (def !== void 0) return canonicalStringify.canonicalStringify(def);
+    if (def !== void 0) return canonicalStringify(def);
   }
-  return canonicalStringify.canonicalStringify(check);
+  return canonicalStringify(check);
 }
 function compare(a, b) {
   const as = String(a);
@@ -158,5 +156,4 @@ function compare(a, b) {
   return as < bs ? -1 : as > bs ? 1 : 0;
 }
 
-exports.fingerprintZodSchema = fingerprintZodSchema;
-//# sourceMappingURL=fingerprint2.cjs.map
+export { fingerprintZodSchema };

package/dist/dev/directive.mjs

@@ -0,0 +1 @@
+export { b as installVRegister, v as vRegister, c as vRegisterFile } from './shared/attaform-dev.D8aoKb89.mjs';

package/dist/dev/history.mjs

@@ -0,0 +1,89 @@
+import { shallowRef, computed } from 'vue';
+import { n as normalizeNumericOption, D as DEFAULT_HISTORY_MAX_SNAPSHOTS, s as structuralSnapshot } from './shared/attaform-dev.ButTkwHd.mjs';
+
+function captureErrorCells(map) {
+  const out = [];
+  for (const [k, cell] of map) {
+    out.push([k, { schema: [...cell.schema], user: [...cell.user] }]);
+  }
+  return out;
+}
+function createHistoryRuntime(kernel, max) {
+  const capacity = Math.max(1, max);
+  function captureSnapshot() {
+    return {
+      form: structuralSnapshot(kernel.form.value),
+      blankPaths: [...kernel.blankPaths],
+      errorCells: captureErrorCells(kernel.errorCells)
+    };
+  }
+  const positions = shallowRef([captureSnapshot()]);
+  const cursor = shallowRef(0);
+  let suppressNext = false;
+  const unsubscribeChange = kernel.onFormChange((_next, meta) => {
+    if (suppressNext) {
+      suppressNext = false;
+      return;
+    }
+    if (meta?.hydration === true) {
+      clear();
+      return;
+    }
+    const next = positions.value.slice(0, cursor.value + 1);
+    next.push(captureSnapshot());
+    while (next.length > capacity) next.shift();
+    positions.value = next;
+    cursor.value = next.length - 1;
+  });
+  function restorePosition(snap) {
+    suppressNext = true;
+    kernel.blankPaths.clear();
+    for (const key of snap.blankPaths) kernel.blankPaths.add(key);
+    kernel.applyFormReplacement(structuralSnapshot(snap.form));
+    kernel.restoreErrorCells(snap.errorCells);
+  }
+  function stepTo(nextCursor) {
+    const snap = positions.value[nextCursor];
+    if (snap === void 0) return false;
+    cursor.value = nextCursor;
+    restorePosition(snap);
+    return true;
+  }
+  function undo() {
+    return cursor.value > 0 && stepTo(cursor.value - 1);
+  }
+  function redo() {
+    return cursor.value < positions.value.length - 1 && stepTo(cursor.value + 1);
+  }
+  function clear() {
+    positions.value = [captureSnapshot()];
+    cursor.value = 0;
+  }
+  return {
+    undo,
+    redo,
+    clear,
+    canUndo: computed(() => cursor.value > 0),
+    canRedo: computed(() => cursor.value < positions.value.length - 1),
+    historySize: computed(() => positions.value.length),
+    dispose() {
+      unsubscribeChange();
+      positions.value = positions.value.slice(cursor.value, cursor.value + 1);
+      cursor.value = 0;
+    }
+  };
+}
+function historyPlugin(options) {
+  const max = normalizeNumericOption({
+    value: options?.max ?? DEFAULT_HISTORY_MAX_SNAPSHOTS,
+    source: "historyPlugin({ max })",
+    allowInfinity: false,
+    min: 0,
+    defaultValue: DEFAULT_HISTORY_MAX_SNAPSHOTS
+  });
+  return {
+    attach: (kernel) => createHistoryRuntime(kernel, max)
+  };
+}
+
+export { historyPlugin };

package/dist/dev/index.mjs

@@ -0,0 +1,5 @@
+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-dev.A-TpJW0B.mjs';
+export { A as AttaformErrorCode, D as DEFAULT_TIMINGS, d as defaultCoercionRules, a as defaultDisplayState, b as defineCoercion, e as escapeForInlineScript, g as gate, i as injectForm, c as injectWizard, f as isUnset, l as lazy, m as makeDefaultDisplayState, u as unset, j as useRegister, k as useWizard } from './shared/attaform-dev.DHuydLAC.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-dev.DD5m2W51.mjs';
+export { a as assignKey, i as isRegisterValue, v as vRegister } from './shared/attaform-dev.D8aoKb89.mjs';
+export { f as fieldMeta, u as useForm, w as withMeta } from './shared/attaform-dev.DrzObAZo.mjs';

package/dist/dev/runtime/plugins/attaform.mjs

@@ -0,0 +1,40 @@
+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-dev.DD5m2W51.mjs';
+
+var attaform_default = defineNuxtPlugin({
+  // `enforce: 'pre'` makes the "we run before any component's setup" claim
+  // explicit. Combined with `prepend: true` on the addPlugin call in
+  // src/nuxt.ts, this guarantees hydration is staged into pendingHydration
+  // before any user plugin or page can call `useForm`. Without it, a user
+  // plugin running first would observe an empty registry and skip hydration.
+  enforce: "pre",
+  setup(nuxtApp) {
+    const isServer = import.meta.server;
+    const config = useRuntimeConfig().public;
+    const { defaults, version } = config.attaform;
+    nuxtApp.vueApp.use(createAttaform({ ssr: isServer, defaults }));
+    nuxtApp.vueApp.provide(kAttaformWizardActiveStepResolver, (param) => {
+      const value = useRoute().query[param];
+      if (typeof value === "string") return value;
+      if (Array.isArray(value) && typeof value[0] === "string") return value[0];
+      return void 0;
+    });
+    if (isServer) {
+      nuxtApp.hook("app:rendered", () => {
+        const state = renderAttaformState(nuxtApp.vueApp);
+        nuxtApp.payload.attaform = state;
+      });
+    } else {
+      const serialized = nuxtApp.payload.attaform;
+      if (serialized !== void 0) {
+        hydrateAttaformState(nuxtApp.vueApp, serialized);
+      }
+      if (import.meta.dev) {
+        const registry = getRegistryFromApp(nuxtApp.vueApp);
+        window[DEVTOOLS_WINDOW_KEY] = { registry, version };
+      }
+    }
+  }
+});
+
+export { attaform_default as default };

package/dist/dev/shared/attaform-dev.A-TpJW0B.mjs

@@ -0,0 +1,207 @@
+class AttaformError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+}
+class InvalidPathError extends AttaformError {
+}
+class InvalidUseFormConfigError extends AttaformError {
+  constructor() {
+    super(
+      "[attaform] useForm received an invalid configuration (a schema directly, no argument, or no `schema` field). Pass it as `useForm({ schema })` \u2014 the schema is one of several configuration options. See https://attaform.dev/docs/reading-the-form/the-form for the full configuration shape." 
+    );
+  }
+}
+class SubmitErrorHandlerError extends AttaformError {
+}
+function toError(value) {
+  if (value instanceof Error) return value;
+  const message = typeof value === "string" && value.length > 0 ? value : `Submit callback threw a non-Error value (${typeof value})`;
+  return new Error(message, { cause: value });
+}
+function normalizeErrorInput(item, scope, defaultCode) {
+  if (item instanceof Error) {
+    return {
+      message: item.message.length > 0 ? item.message : "Unknown error",
+      path: scope !== void 0 ? [...scope] : [],
+      code: defaultCode
+    };
+  }
+  const entry = {
+    message: typeof item.message === "string" && item.message.length > 0 ? item.message : "Unknown error",
+    path: scope !== void 0 ? [...scope] : Array.isArray(item.path) ? [...item.path] : [],
+    code: typeof item.code === "string" && item.code.length > 0 ? item.code : defaultCode
+  };
+  if (item.data !== void 0) entry.data = item.data;
+  return entry;
+}
+function normalizeErrorInputs(input, scope, defaultCode) {
+  const items = Array.isArray(input) ? input : [input];
+  return items.map((item) => normalizeErrorInput(item, scope, defaultCode));
+}
+function* cellEntriesFor(cells, side) {
+  for (const [key, cell] of cells) {
+    const list = cell[side];
+    if (list.length > 0) yield [key, list];
+  }
+}
+class RegistryNotInstalledError extends AttaformError {
+  constructor() {
+    super(
+      "[attaform] No registry attached to this Vue app. Component-level useForm / injectForm / useRegister auto-install the registry, but SSR helpers (renderAttaformState, hydrateAttaformState) run outside setup and require an explicit `app.use(createAttaform())` at server-render time. Add it to your SSR entry, before `renderToString`." 
+    );
+  }
+}
+class OutsideSetupError extends AttaformError {
+  constructor() {
+    super(
+      "[attaform] useForm / injectForm called outside Vue setup(). Move into setup or mount a child component to trigger from an event." 
+    );
+  }
+}
+class ReservedFormKeyError extends AttaformError {
+  constructor(key) {
+    super(
+      `[attaform] Form key "${key}" uses the reserved "__atta:" namespace. Use a different prefix \u2014 "__atta:" is for library-internal synthetic keys (anonymous useForm() calls without an explicit key).` 
+    );
+  }
+}
+function groupErrorsByKey(entries) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const raw of entries) {
+    const { key } = canonicalizePath(raw.path);
+    const list = grouped.get(key);
+    if (list === void 0) grouped.set(key, [raw]);
+    else list.push(raw);
+  }
+  return grouped;
+}
+
+const INTEGER_SEGMENT = /^(?:0|[1-9]\d*)$/;
+const SET_MEMBER_SEGMENT = "__atta:member";
+function mapSegmentKeys(value) {
+  const keys = [];
+  for (const key of value.keys()) {
+    if (typeof key === "string") keys.push(key);
+    else if (typeof key === "number" && Number.isInteger(key) && key >= 0) keys.push(key);
+    else return null;
+  }
+  return keys;
+}
+function normalizeSegment(raw) {
+  if (typeof raw === "number") {
+    if (!Number.isInteger(raw) || raw < 0) {
+      throw new InvalidPathError(
+        `Path segments must be non-negative integers when numeric; got ${String(raw)}` 
+      );
+    }
+    return raw;
+  }
+  if (INTEGER_SEGMENT.test(raw)) return Number(raw);
+  return raw;
+}
+function parseDottedPath(path) {
+  if (path.length === 0) return [""];
+  const rawSegments = path.split(".");
+  const segments = [];
+  for (const raw of rawSegments) {
+    if (raw.length === 0) {
+      throw new InvalidPathError(
+        `Path '${path}' has an empty segment; use the array form for empty keys.` 
+      );
+    }
+    segments.push(normalizeSegment(raw));
+  }
+  return segments;
+}
+const CANONICAL_STRING_CACHE_MAX = 128;
+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) {
+    const oldest = pathKeyToSegments.keys().next().value;
+    if (oldest !== void 0) pathKeyToSegments.delete(oldest);
+  }
+  pathKeyToSegments.set(key, segments);
+}
+function segmentsForPathKey(key) {
+  const cached = pathKeyToSegments.get(key);
+  if (cached !== void 0) return cached;
+  let parsed;
+  try {
+    parsed = JSON.parse(key);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed)) return null;
+  const segments = [];
+  for (const raw of parsed) {
+    if (typeof raw !== "string" && typeof raw !== "number") return null;
+    segments.push(normalizeSegment(raw));
+  }
+  rememberSegmentsForPathKey(key, segments);
+  return segments;
+}
+function canonicalizePath(input) {
+  if (typeof input === "string") {
+    const cached = canonicalStringCache.get(input);
+    if (cached !== void 0) return cached;
+    const segments = parseDottedPath(input);
+    const key = JSON.stringify(segments);
+    const entry = { segments, key };
+    if (canonicalStringCache.size >= CANONICAL_STRING_CACHE_MAX) {
+      const oldest = canonicalStringCache.keys().next().value;
+      if (oldest !== void 0) canonicalStringCache.delete(oldest);
+    }
+    canonicalStringCache.set(input, entry);
+    rememberSegmentsForPathKey(key, segments);
+    return entry;
+  }
+  return keyForSegments(input);
+}
+function keyForSegments(input) {
+  const segments = Array.from(input).map(normalizeSegment);
+  const key = JSON.stringify(segments);
+  rememberSegmentsForPathKey(key, segments);
+  return { segments, key };
+}
+function segmentsToDotted(segments) {
+  return segments.join(".");
+}
+function pathKeyToDotted(key) {
+  const segments = segmentsForPathKey(key);
+  if (segments === null) return null;
+  return segmentsToDotted(segments);
+}
+function coerceToPathKey(input) {
+  if (input.length > 0 && input.charCodeAt(0) === 91) {
+    try {
+      const parsed = JSON.parse(input);
+      if (Array.isArray(parsed) && parsed.every((s) => typeof s === "string" || typeof s === "number")) {
+        return input;
+      }
+    } catch {
+    }
+  }
+  return canonicalizePath(input).key;
+}
+const ROOT_PATH = Object.freeze([]);
+const ROOT_PATH_KEY = "[]";
+function isPathPrefix(prefix, path) {
+  if (path.length < prefix.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (path[i] !== prefix[i]) return false;
+  }
+  return true;
+}
+function pathsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+export { AttaformError as A, InvalidPathError as I, OutsideSetupError as O, ROOT_PATH as R, SubmitErrorHandlerError as S, InvalidUseFormConfigError as a, ROOT_PATH_KEY as b, RegistryNotInstalledError as c, ReservedFormKeyError as d, canonicalizePath as e, pathsEqual as f, pathKeyToDotted as g, SET_MEMBER_SEGMENT as h, isPathPrefix as i, cellEntriesFor as j, keyForSegments as k, groupErrorsByKey as l, mapSegmentKeys as m, normalizeErrorInput as n, normalizeErrorInputs as o, parseDottedPath as p, coerceToPathKey as q, segmentsForPathKey as s, toError as t };