attaform 0.17.2 → 0.18.1

package/dist/shared/{attaform.CHorcsIU.d.cts → attaform.M33WKVV4.d.cts}

@@ -1,21 +1,27 @@
 import { z } from 'zod';
-import { G as GenericForm, s as FlatPath, B as NestedType, U as UseFormConfiguration, b as AbstractSchema, D as DeepPartial, c as DefaultValuesShape, ag as ValidateOnConfig, d as UseFormReturnType } from './attaform.C_5aB6EQ.cjs';
+import { G as GenericForm, t as FlatPath, O as NestedType, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, D as DefaultValuesInput, ak as ValidateOnConfig, b as UseFormReturnType } from './attaform.Dj9mwbaV.cjs';
 
 /**
  * The shape `form.values.<key>` returns at runtime.
  *
  * Per leaf:
  *
- * 1. `z.preprocess(fn, inner)` — compiles to `ZodPipe<ZodTransform, inner>`.
- *    The preprocess fn fires at the write boundary (synthesized into
- *    `setValue`), so storage holds whatever `inner` stores. Recurse
- *    `StorageShape` on `inner` so a defaulted leaf inside `inner` still
- *    reads `T` (not `T | undefined`).
+ * 1. Schema-side input normalizers — `z.preprocess(fn, inner)` AND
+ *    `z.coerce.X()`. Zod v4 represents these differently
+ *    (`ZodPipe<ZodTransform, inner>` for preprocess; a primitive
+ *    with `def.coerce === true` for coerce), but they share the
+ *    same type-level marker: `_zod.input` is `unknown`. The
+ *    normalizer runs at parse time, NOT at the write boundary, so
+ *    storage holds the consumer's raw input and the type collapses
+ *    to `unknown` to match. Reach the typed value via
+ *    `handleSubmit`, `validate`, or `validateAsync` — they re-parse
+ *    storage through the wrapper.
  *
  * 2. `inner.transform(fn)` — compiles to `ZodPipe<inner, ZodTransform>`.
  *    Transforms fire at submit / validate, NOT at the write boundary,
  *    so storage holds whatever `inner` stores. Recurse `StorageShape`
- *    on `inner` for the same reason.
+ *    on `inner` so a defaulted leaf inside `inner` still reads `T`
+ *    (not `T | undefined`).
  *
  *    A bare top-level `ZodTransform` (no `in` schema) reads
  *    `_zod.input` directly — there's no inner to recurse into.
@@ -30,12 +36,12 @@ import { G as GenericForm, s as FlatPath, B as NestedType, U as UseFormConfigura
  *    Nested objects delegate to Zod's own recursion on `_zod.output`,
  *    which peels nested defaults inside structural containers.
  *
- * Recursion: the alias calls itself on the non-transform side of a
- * pipe so the inner shape gets the same per-key storage treatment as
- * the top level. Without it, an inner `.default(...)` inside a
- * transformed object would peel back to `T | undefined` (the broad
- * input contract). Recursion only fires for pipe leaves — most leaves
- * skip it.
+ * Detection order: case 1 wins via the `_zod.input` IsUnknown check
+ * before the pipe/transform cascade fires, so wrapped variants like
+ * `z.coerce.number().optional()` (input = `unknown | undefined` →
+ * collapses to `unknown`) and `z.preprocess(fn, z.object(...))` (input
+ * = `unknown`) both land on `unknown` without descending. The IsAny
+ * filter keeps `z.any()` from being mistaken for coerce.
  *
  * Implementation note: direct `_zod` property access mirrors Zod's
  * own `$InferObjectOutput` / `$InferObjectInput`, which read
@@ -61,7 +67,26 @@ type StorageShape<S> = S extends {
 } ? {
     [K in keyof Shape]-?: StorageLeaf<Shape[K]>;
 } : StorageLeaf<S>;
-type StorageLeaf<L> = L extends {
+/**
+ * Detects a schema whose `_zod.input` is `unknown` — the marker both
+ * `z.preprocess(fn, _)` and `z.coerce.X()` share in Zod v4. Excludes
+ * `any` via the canonical `0 extends 1 & T` test so `z.any()` leaves
+ * fall through to the cascade below and keep their `any` typing.
+ */
+type InputIsUnknown<L> = L extends {
+    _zod: {
+        input: infer In;
+    };
+} ? 0 extends 1 & In ? false : unknown extends In ? true : false : false;
+/**
+ * Implementation-detail per-leaf branching for `StorageShape`.
+ * Exported so the bundled `.d.ts` carries a single alias body —
+ * every leaf of a Zod object schema otherwise re-emits the full
+ * pipe / transform / default conditional ladder, which compounds
+ * badly with multiple complex schemas in the same scope. Consumers
+ * should reach for `StorageShape` instead.
+ */
+type StorageLeaf<L> = InputIsUnknown<L> extends true ? unknown : L extends {
     _zod: {
         def: {
             type: 'pipe';
@@ -69,13 +94,7 @@ type StorageLeaf<L> = L extends {
             out: infer B;
         };
     };
-} ? A extends {
-    _zod: {
-        def: {
-            type: 'transform';
-        };
-    };
-} ? StorageShape<B> : B extends {
+} ? B extends {
     _zod: {
         def: {
             type: 'transform';
@@ -157,9 +176,24 @@ type PathOutput<Schema extends z.ZodType, Path extends string> = z.output<Schema
  *
  * For Zod v3, import from `attaform/zod-v3` instead.
  */
-declare function useForm<Schema extends z.ZodObject>(configuration: Omit<UseFormConfiguration<z.input<Schema> extends GenericForm ? z.input<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never, AbstractSchema<z.input<Schema> extends GenericForm ? z.input<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never>, DeepPartial<DefaultValuesShape<z.input<Schema> extends GenericForm ? z.input<Schema> : never>>>, 'schema' | 'validateOn' | 'debounceMs'> & {
+/**
+ * `FormOf` / `OutOf` / `ReadOf` factor the three identical-shape
+ * conditionals out of `useForm`'s public signature. The bundled
+ * `.d.ts` then carries one alias per shape rather than re-inlining
+ * `z.input<Schema> extends GenericForm ? z.input<Schema> : never`
+ * four times — which is what produces TS2589 ("Type instantiation
+ * is excessively deep") on consumer call sites with complex schemas
+ * (discriminated unions, transform pipes, deep `.register()` chains).
+ * Each alias is computed once per `Schema` instantiation; downstream
+ * generics ride on the alias rather than re-evaluating the
+ * conditional from scratch.
+ */
+type FormOf<Schema extends z.ZodObject> = z.input<Schema> extends GenericForm ? z.input<Schema> : never;
+type OutOf<Schema extends z.ZodObject> = z.output<Schema> extends GenericForm ? z.output<Schema> : never;
+type ReadOf<Schema extends z.ZodObject> = StorageShape<Schema> extends GenericForm ? StorageShape<Schema> : never;
+declare function useForm<Schema extends z.ZodObject, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<FormOf<Schema>, OutOf<Schema>, AbstractSchema<FormOf<Schema>, OutOf<Schema>>, DefaultValuesInput<FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
     schema: Schema;
-} & ValidateOnConfig): UseFormReturnType<z.input<Schema> extends GenericForm ? z.input<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never, StorageShape<Schema> extends GenericForm ? StorageShape<Schema> : never>;
+} & ValidateOnConfig): UseFormReturnType<FormOf<Schema>, OutOf<Schema>, ReadOf<Schema>, K>;
 
 export { useForm as u };
 export type { PathInput as P, StorageShape as S, PathOutput as a };

package/dist/shared/{attaform.CIEQgJnM.mjs → attaform.Xhg0AYNa.mjs}

@@ -1,4 +1,4 @@
-import { shallowReactive, getCurrentInstance, inject, shallowRef, onBeforeMount, onBeforeUpdate, onMounted, nextTick, warn, isRef } from 'vue';
+import { shallowReactive, getCurrentInstance, inject, shallowRef, onBeforeMount, onBeforeUpdate, onMounted, nextTick, warn, isRef, effectScope, watch } from 'vue';
 
 const __DEV__ = typeof process !== "undefined" && process.env["NODE_ENV"] !== "production";
 
@@ -76,43 +76,118 @@ function detectSSR(options = {}) {
 }
 
 const kAttaformRegistry = Symbol.for("attaform:registry");
+const kAttaformAncestorWizard = Symbol.for(
+  "attaform:ancestor-wizard"
+);
+const kAttaformWizardActiveStepResolver = Symbol.for(
+  "attaform:wizard-active-step-resolver"
+);
 const kFormContext = Symbol.for("attaform:form-context");
 const kFormInstanceId = 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());
   const consumers = /* @__PURE__ */ new Map();
   const evicting = /* @__PURE__ */ new Set();
+  const pendingEvictions = /* @__PURE__ */ new Map();
+  function cancelPendingEviction(key) {
+    const pending = pendingEvictions.get(key);
+    if (pending === void 0) return;
+    pending.cancelled = true;
+    pendingEvictions.delete(key);
+  }
   function trackConsumer(key) {
+    cancelPendingEviction(key);
     consumers.set(key, (consumers.get(key) ?? 0) + 1);
     let disposed = false;
     return () => {
       if (disposed) return;
       disposed = true;
       const remaining = (consumers.get(key) ?? 1) - 1;
-      if (remaining <= 0) {
+      if (remaining > 0) {
+        consumers.set(key, remaining);
+        return;
+      }
+      consumers.delete(key);
+      const token = { cancelled: false };
+      pendingEvictions.set(key, token);
+      queueMicrotask(() => {
+        if (token.cancelled) return;
+        if (pendingEvictions.get(key) !== token) return;
+        pendingEvictions.delete(key);
         const state = forms.get(key);
-        consumers.delete(key);
         forms.delete(key);
-        if (state !== void 0) {
-          evicting.add(state);
-          void state.awaitPendingWrites().catch(() => void 0).finally(() => {
-            evicting.delete(state);
-            state.dispose();
-          });
-        }
-      } else {
-        consumers.set(key, remaining);
+        if (state === void 0) return;
+        evicting.add(state);
+        void state.awaitPendingWrites().catch(() => void 0).finally(() => {
+          evicting.delete(state);
+          state.dispose();
+        });
+      });
+    };
+  }
+  const wizardConsumers = /* @__PURE__ */ new Map();
+  const pendingWizardEvictions = /* @__PURE__ */ new Map();
+  function cancelPendingWizardEviction(key) {
+    const pending = pendingWizardEvictions.get(key);
+    if (pending === void 0) return;
+    pending.cancelled = true;
+    pendingWizardEvictions.delete(key);
+  }
+  function trackWizardConsumer(key) {
+    cancelPendingWizardEviction(key);
+    wizardConsumers.set(key, (wizardConsumers.get(key) ?? 0) + 1);
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      const remaining = (wizardConsumers.get(key) ?? 1) - 1;
+      if (remaining > 0) {
+        wizardConsumers.set(key, remaining);
+        return;
       }
+      wizardConsumers.delete(key);
+      const token = { cancelled: false };
+      pendingWizardEvictions.set(key, token);
+      queueMicrotask(() => {
+        if (token.cancelled) return;
+        if (pendingWizardEvictions.get(key) !== token) return;
+        pendingWizardEvictions.delete(key);
+        wizards.delete(key);
+      });
     };
   }
   async function shutdown() {
     const states = [...forms.values(), ...evicting];
     await Promise.allSettled(states.map((state) => state.awaitPendingWrites()));
   }
-  return { forms, pendingHydration, ssr, defaults, trackConsumer, shutdown };
+  const prefetchEnqueued = /* @__PURE__ */ new Set();
+  const prefetchSkipped = /* @__PURE__ */ new Set();
+  function enqueuePrefetch(key) {
+    prefetchEnqueued.add(key);
+  }
+  function skipPrefetch(key) {
+    prefetchSkipped.add(key);
+  }
+  function shouldPrefetch(key) {
+    return prefetchEnqueued.has(key) && !prefetchSkipped.has(key);
+  }
+  return {
+    forms,
+    wizards,
+    pendingHydration,
+    ssr,
+    defaults,
+    trackConsumer,
+    trackWizardConsumer,
+    enqueuePrefetch,
+    skipPrefetch,
+    shouldPrefetch,
+    shutdown
+  };
 }
 function useRegistry() {
   const instance = getCurrentInstance();
@@ -282,6 +357,17 @@ function useRegister() {
     if ("registerValue" in rawAttrs) {
       capturedRegisterValue.value = rawAttrs["registerValue"];
       delete rawAttrs["registerValue"];
+    } else {
+      const dirs = instance.vnode.dirs;
+      if (dirs !== null && dirs !== void 0) {
+        for (const dir of dirs) {
+          const marked = dir.dir?.[V_REGISTER_MARKER];
+          if (marked === true) {
+            capturedRegisterValue.value = dir.value;
+            break;
+          }
+        }
+      }
     }
     if ("value" in rawAttrs) delete rawAttrs["value"];
   };
@@ -632,6 +718,12 @@ const getModelAssigner = (el, vnode, registerValue) => {
     };
   }
   const defaultAssigner = (value) => {
+    if (value === void 0 && registerValue.acceptsUndefined) {
+      return registerValue.setValueWithInternalPath(
+        void 0,
+        computePersistMeta(el, registerValue)
+      );
+    }
     const r = runTransforms(value, registerValue);
     if (!r.ok) return false;
     const coerced = applyCoerce(r.value, registerValue);
@@ -640,9 +732,10 @@ const getModelAssigner = (el, vnode, registerValue) => {
   defaultAssigner[DEFAULT_ASSIGNER_TAG] = true;
   return defaultAssigner;
 };
-function syncPersistOptIn(el, value, oldValue) {
+function syncPersistOptIn(el, value, oldValue, vnodeType) {
   const wasOptedIn = isRegisterValue(oldValue) && oldValue.persist === true;
-  const wantsOptIn = isRegisterValue(value) && value.persist === true;
+  const isFileInput = el.tagName === "INPUT" && (vnodeType === "file" || el.type === "file");
+  const wantsOptIn = !isFileInput && isRegisterValue(value) && value.persist === true;
   if (!wasOptedIn && !wantsOptIn) return;
   const elementId = getOrAssignElementId(el);
   if (wasOptedIn) {
@@ -768,7 +861,13 @@ const vRegisterText = {
         }
         if (isRegisterValue(value)) writeLastTypedForm(value, typedString);
       }
-      el[assignKey]?.(domValue);
+      if (domValue === "" && isRegisterValue(value) && !value.acceptsString && !value.acceptsUndefined) {
+        writeLastTypedForm(value, null);
+        value.markBlank();
+        return;
+      }
+      const commit = domValue === "" && isRegisterValue(value) && value.acceptsUndefined ? void 0 : domValue;
+      el[assignKey]?.(commit);
       if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
         const storage = value.innerRef.value;
         if (storage !== domValue) {
@@ -1120,7 +1219,7 @@ const SUPPORTED_TAGS = /* @__PURE__ */ new Set(["INPUT", "TEXTAREA", "SELECT"]);
 const warnedUnsupportedElements = __DEV__ ? /* @__PURE__ */ new WeakSet() : null;
 const vRegisterDynamic = {
   created(el, binding, vnode) {
-    syncPersistOptIn(el, binding.value, void 0);
+    syncPersistOptIn(el, binding.value, void 0, vnode.props?.["type"]);
     syncMultiTabOptOut(binding.value, void 0);
     callModelHook(el, binding, vnode, null, "created");
     if (__DEV__ && warnedUnsupportedElements !== null && !SUPPORTED_TAGS.has(el.tagName) && !warnedUnsupportedElements.has(el)) {
@@ -1142,7 +1241,7 @@ const vRegisterDynamic = {
     callModelHook(el, binding, vnode, null, "mounted");
   },
   beforeUpdate(el, binding, vnode, prevVNode) {
-    syncPersistOptIn(el, binding.value, binding.oldValue);
+    syncPersistOptIn(el, binding.value, binding.oldValue, vnode.props?.["type"]);
     syncMultiTabOptOut(binding.value, binding.oldValue);
     syncElementRegistration(el, binding.value, binding.oldValue);
     callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
@@ -1163,18 +1262,83 @@ const vRegisterDynamic = {
     delete el[assignKey];
   }
 };
-const vRegisterFileNoop = {
+function isBlankFileValue(value) {
+  if (value === null || value === void 0) return true;
+  if (Array.isArray(value) && value.length === 0) return true;
+  if (typeof FileList !== "undefined" && value instanceof FileList && value.length === 0)
+    return true;
+  return false;
+}
+function readFilesFromInput(el) {
+  const files = el.files;
+  if (el.multiple) {
+    return files === null ? [] : Array.from(files);
+  }
+  if (files === null || files.length === 0) return null;
+  return files.item(0);
+}
+const warnedPersistedFileForms = __DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+function maybeWarnPersistedFile(value) {
+  if (!__DEV__ || warnedPersistedFileForms === null) return;
+  if (value.persist !== true) return;
+  let warnedPaths = warnedPersistedFileForms.get(value.persistOptIns);
+  if (warnedPaths === void 0) {
+    warnedPaths = /* @__PURE__ */ new Set();
+    warnedPersistedFileForms.set(value.persistOptIns, warnedPaths);
+  }
+  if (warnedPaths.has(value.path)) return;
+  warnedPaths.add(value.path);
+  warn(
+    `[attaform] register('${value.path}', { persist: true }) on <input type="file"> \u2014 files can't ride a refresh (browsers block programmatic writes to <input type="file">), so this path won't be saved. For long-lived flows, upload on selection and persist the resulting URL or ID in a sibling string field.`
+  );
+}
+const fileScopeKey = Symbol.for("attaform:file-scope");
+const vRegisterFile = {
   created(el, { value }) {
     if (!isRegisterValue(value)) return;
-    value.registerElement(el);
-    if (__DEV__) {
-      warn(
-        '[attaform] v-register on <input type="file"> is not supported. Handle uploads with a manual @change listener.'
+    const input = el;
+    value.registerElement(input);
+    maybeWarnPersistedFile(value);
+    const currentRaw = value.innerRef.value;
+    if (isBlankFileValue(currentRaw)) {
+      const blankShape = input.multiple ? [] : null;
+      value.setValueWithInternalPath(blankShape, { blank: true });
+    }
+    addEventListener(input, "change", () => {
+      const next = readFilesFromInput(input);
+      const blank = isBlankFileValue(next);
+      value.setValueWithInternalPath(next, blank ? { blank: true } : void 0);
+    });
+    const scope = effectScope(true);
+    scope.run(() => {
+      watch(
+        value.innerRef,
+        (next) => {
+          if (!isBlankFileValue(next)) return;
+          value.setValueWithInternalPath(next, { blank: true });
+          if (input.value !== "") input.value = "";
+        },
+        { flush: "post" }
       );
+    });
+    input[fileScopeKey] = () => scope.stop();
+  },
+  beforeUpdate(el, { value }) {
+    if (!isRegisterValue(value)) return;
+    const input = el;
+    const currentRaw = value.innerRef.value;
+    if (isBlankFileValue(currentRaw)) {
+      value.setValueWithInternalPath(currentRaw, { blank: true });
+      if (input.value !== "") input.value = "";
     }
   },
   beforeUnmount(el, { value }) {
     removeTrackedListeners(el);
+    const stop = el[fileScopeKey];
+    if (stop !== void 0) {
+      stop();
+      delete el[fileScopeKey];
+    }
     if (!isRegisterValue(value)) return;
     value.deregisterElement(el);
   }
@@ -1183,7 +1347,7 @@ function resolveDynamicModel(tagName, type) {
   if (tagName === "SELECT") return vRegisterSelect;
   if (tagName === "TEXTAREA") return vRegisterText;
   if (typeof type !== "string") return vRegisterText;
-  if (type === "file") return vRegisterFileNoop;
+  if (type === "file") return vRegisterFile;
   if (type === "checkbox") return vRegisterCheckbox;
   if (type === "radio") return vRegisterRadio;
   return vRegisterText;
@@ -1193,7 +1357,9 @@ function callModelHook(el, binding, vnode, prevVNode, hook) {
   const fn = modelToUse[hook];
   fn?.(el, binding, vnode, prevVNode);
 }
+const V_REGISTER_MARKER = Symbol.for("attaform:v-register-directive");
 const vRegister = vRegisterDynamic;
+vRegisterDynamic[V_REGISTER_MARKER] = true;
 
 function installAttaformOnApp(app, options, source) {
   if (app._attaform !== void 0) {
@@ -1230,5 +1396,113 @@ function createAttaform(options = {}) {
   return plugin;
 }
 
-export { AnonPersistError as A, DEFAULT_SENSITIVE_NAMES as D, InvalidPathError as I, OutsideSetupError as O, RegistryNotInstalledError as R, SensitivePersistFieldError as S, __DEV__ as _, AttaformError as a, InvalidUseFormConfigError as b, createAttaform as c, ReservedFormKeyError as d, SubmitErrorHandlerError as e, assignKey as f, getRegistryFromApp as g, createRegistry as h, isRegisterValue as i, useRegistry as j, kAttaformRegistry as k, captureUserCallSite as l, enforceSensitiveCheck as m, isSensitivePath as n, createPersistOptInRegistry as o, ensureAttaformInstalled as p, kFormContext as q, kFormInstanceId as r, segmentMatchesSensitive as s, createIsSensitivePath as t, useRegister as u, vRegister as v, createSegmentMatchesSensitive as w };
-//# sourceMappingURL=attaform.CIEQgJnM.mjs.map
+const INTEGER_SEGMENT = /^(?:0|[1-9]\d*)$/;
+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 segments2 = parseDottedPath(input);
+    const key2 = JSON.stringify(segments2);
+    const entry = { segments: segments2, key: key2 };
+    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(key2, segments2);
+    return entry;
+  }
+  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 = "[]";
+const FORM_ERRORS_PATH = Object.freeze([""]);
+const FORM_ERRORS_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;
+}
+
+export { AnonPersistError as A, isSensitivePath as B, createPersistOptInRegistry as C, DEFAULT_SENSITIVE_NAMES as D, ensureAttaformInstalled as E, FORM_ERRORS_PATH_KEY as F, kFormContext as G, kFormInstanceId as H, InvalidPathError as I, createIsSensitivePath as J, createSegmentMatchesSensitive as K, kAttaformAncestorWizard as L, OutsideSetupError as O, ROOT_PATH as R, SensitivePersistFieldError as S, __DEV__ as _, canonicalizePath as a, AttaformError as b, createAttaform as c, InvalidUseFormConfigError as d, ROOT_PATH_KEY as e, RegistryNotInstalledError as f, getRegistryFromApp as g, ReservedFormKeyError as h, SubmitErrorHandlerError as i, assignKey as j, kAttaformWizardActiveStepResolver as k, createRegistry as l, isPathPrefix as m, isRegisterValue as n, kAttaformRegistry as o, parseDottedPath as p, useRegistry as q, pathKeyToDotted as r, segmentsForPathKey as s, captureUserCallSite as t, useRegister as u, vRegister as v, enforceSensitiveCheck as w, FORM_ERRORS_PATH as x, coerceToPathKey as y, segmentMatchesSensitive as z };
+//# sourceMappingURL=attaform.Xhg0AYNa.mjs.map