attaform 0.25.0 → 0.27.0

package/dist/shared/{attaform.BkUzunyB.cjs → attaform.DQT7_-FO.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
 const vue = require('vue');
-const paths = require('./attaform.3heDHayA.cjs');
-const registerProtocol = require('./attaform.ZXZ6dH72.cjs');
+const devtoolsShared = require('./attaform.Co5LNRnv.cjs');
+const registerProtocol = require('./attaform.yUrz7C2z.cjs');
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -31,7 +31,7 @@ function safeOwnHas(target, key) {
   return Object.prototype.hasOwnProperty.call(target, key);
 }
 
-const NOT_FOUND = Symbol("NOT_FOUND");
+const NOT_FOUND = /* @__PURE__ */ Symbol("NOT_FOUND");
 function descendStep(value, segment) {
   if (value === null || value === void 0) return NOT_FOUND;
   if (typeof value !== "object") return NOT_FOUND;
@@ -434,7 +434,7 @@ function applyChangedKeys(target, source, arrayOpPath, currentPath) {
   const targetIsArray = Array.isArray(target);
   const sourceIsArray = Array.isArray(source);
   if (targetIsArray !== sourceIsArray) return false;
-  const ROOT_SENTINEL = Symbol.for("attaform.applyChangedKeys.rootMismatch");
+  const ROOT_SENTINEL = /* @__PURE__ */ Symbol.for("attaform.applyChangedKeys.rootMismatch");
   const changedFirstSegments = /* @__PURE__ */ new Set();
   diffAndApply(target, source, [], (patch) => {
     if (patch.path.length === 0) {
@@ -447,7 +447,7 @@ function applyChangedKeys(target, source, arrayOpPath, currentPath) {
   if (targetIsArray) {
     const t = target;
     const s = source;
-    if (arrayOpPath === null || paths.pathsEqual(currentPath, arrayOpPath)) {
+    if (arrayOpPath === null || devtoolsShared.pathsEqual(currentPath, arrayOpPath)) {
       if (t.length > s.length) t.length = s.length;
       for (const idx of changedFirstSegments) {
         if (typeof idx === "symbol") continue;
@@ -463,7 +463,7 @@ function applyChangedKeys(target, source, arrayOpPath, currentPath) {
         const childPath = appendSegment(currentPath, i);
         const curEl = t[i];
         const nextEl = s[i];
-        if (paths.isPathPrefix(childPath, arrayOpPath) && isDescendable(curEl) && isDescendable(nextEl) && applyChangedKeys(curEl, nextEl, arrayOpPath, childPath)) {
+        if (devtoolsShared.isPathPrefix(childPath, arrayOpPath) && isDescendable(curEl) && isDescendable(nextEl) && applyChangedKeys(curEl, nextEl, arrayOpPath, childPath)) {
           continue;
         }
         t[i] = nextEl;
@@ -584,7 +584,18 @@ const AttaformErrorCode = {
    * produced `ValidationError` carrying a stable, branchable identifier.
    * Override it per error by passing your own `code` (`api:…`, `auth:…`).
    */
-  UserError: "atta:user-error"
+  UserError: "atta:user-error",
+  /**
+   * Stamped on a `ValidationError` synthesized from a throw or rejection
+   * out of a `handleSubmit` `onSubmit` callback. The raw error also lands
+   * on `form.meta.submitError` (a raw-`Error` inspection channel); this
+   * code marks the copy piped into the user-error layer so the failure
+   * also surfaces on `form.errors` / `meta.ownErrors` / `firstOwnError`
+   * where the UI already reads. A throw carrying its own `path` / `code`
+   * keeps them; a bare `Error` or a non-Error throw defaults here at the
+   * form-level path `[]`.
+   */
+  SubmitError: "atta:submit-error"
 };
 function makeBlankRequiredError(segments, formKey) {
   return {
@@ -660,7 +671,7 @@ 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) {
-    if (paths.__DEV__) {
+    if (devtoolsShared.__DEV__) {
       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)}.`
@@ -739,7 +750,7 @@ function buildFieldStateAccessor(state, formInstanceId, getFormMetaBase, options
   const cache = /* @__PURE__ */ new Map();
   const predicate = options?.getDisplayState;
   return function getFieldState(pathInput) {
-    const { segments, key } = paths.canonicalizePath(pathInput);
+    const { segments, key } = devtoolsShared.canonicalizePath(pathInput);
     const cached = cache.get(key);
     if (cached !== void 0) return cached;
     const c = vue.computed(
@@ -792,6 +803,11 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
     elements: elementsArr,
     updatedAt: record?.updatedAt ?? null,
     errors,
+    // A leaf has no descendants, so its own-bucket errors ARE its subtree
+    // errors. Reuse the same array reference: referential `ownErrors ===
+    // errors`, and no second read of the whole-form `derivedBlankErrors`
+    // map (preserves the P3 blank-reactivity optimization above).
+    ownErrors: errors,
     validating,
     valid,
     transforming,
@@ -871,7 +887,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   const blurredLeafSegments = [];
   const descendantLeaves = [];
   visitActiveLeafPaths(value, segments, (leafSegments) => {
-    const { key: leafKey } = paths.keyForSegments(leafSegments);
+    const { key: leafKey } = devtoolsShared.keyForSegments(leafSegments);
     const entry = state.originals.get(leafKey);
     if (entry === void 0) return;
     descendantLeaves.push({ key: leafKey, segments: entry.segments });
@@ -926,7 +942,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
     if (ePath.length === segments.length && ePath.every((s, i) => s === segments[i])) return false;
     if (submissionAttempts > 0) return true;
     if (ePath.length === 1 && ePath[0] === "") return blurredAfterInteraction;
-    return blurredLeafSegments.some((s) => paths.isPathPrefix(ePath, s));
+    return blurredLeafSegments.some((s) => devtoolsShared.isPathPrefix(ePath, s));
   });
   if (!asyncPending && state.pathHasAsyncValidation(segments)) asyncPending = true;
   if ((state.fieldValidationCounts.get(key) ?? 0) > 0) {
@@ -970,6 +986,12 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
       elements: EMPTY_ELEMENTS,
       updatedAt,
       errors,
+      // The container's OWN bucket only (this exact path), excluding every
+      // descendant that `errors` rolls up: a cross-field `.refine()` here,
+      // or `setErrors` pinned at this node. The same raw union the leaf
+      // builds from the three stores; the container already depends on all
+      // three via `aggregateErrorsAt`, so there's no new reactivity cost.
+      ownErrors: state.getErrorsForPath(segments),
       validating,
       valid,
       transforming,
@@ -1008,6 +1030,7 @@ function buildContainerFieldState(state, segments, key, formInstanceId, getFormM
 }
 function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingSince, transformingSince, revealedDescendantError, isRoot, getDisplayState) {
   const firstError = base.errors[0];
+  const firstOwnError = base.ownErrors[0];
   const predicate = getDisplayState ?? state.getDisplayState;
   const formMeta = getFormMetaBase();
   const ctx = {
@@ -1024,7 +1047,7 @@ function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingS
   try {
     machine = state.displayEngine.resolve(key, ctx, predicate);
   } catch (err) {
-    if (paths.__DEV__ && !warnedDisplayStatePredicates.has(predicate)) {
+    if (devtoolsShared.__DEV__ && !warnedDisplayStatePredicates.has(predicate)) {
       warnedDisplayStatePredicates.add(predicate);
       console.warn(
         "[attaform] custom getDisplayState threw \u2014 falling back to defaultDisplayState. Subsequent throws from the same predicate will not warn again.",
@@ -1043,7 +1066,8 @@ function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingS
     showPending: displayState === "pending",
     showSuccess: displayState === "success",
     showIdle: displayState === "idle",
-    firstError
+    firstError,
+    firstOwnError
   };
 }
 function aggregateErrorsAt(state, prefix) {
@@ -1052,9 +1076,9 @@ function aggregateErrorsAt(state, prefix) {
   const collect = (errs) => {
     for (const [pathKey, list] of errs) {
       if (list.length === 0) continue;
-      const segs = paths.segmentsForPathKey(pathKey);
+      const segs = devtoolsShared.segmentsForPathKey(pathKey);
       if (segs === null) continue;
-      if (!paths.isPathPrefix(prefix, segs)) continue;
+      if (!devtoolsShared.isPathPrefix(prefix, segs)) continue;
       if (segs.length > 0 && !hasAtPath(formValue, segs)) continue;
       const ordinal = state.ensurePathOrdinal(pathKey);
       const existing = buckets.get(ordinal);
@@ -1096,7 +1120,7 @@ function isArrayPath(state, segments) {
 }
 
 function warnReadOnly(surface, action, key) {
-  if (!paths.__DEV__) return;
+  if (!devtoolsShared.__DEV__) return;
   const phrase = action === "write" ? `write to "${String(key)}"` : `${action} of "${String(key)}"`;
   console.warn(
     `[attaform] ${surface} is read-only \u2014 ${phrase} was ignored. Mutate the form via setValue / the directive / field-array helpers instead.`
@@ -1180,7 +1204,7 @@ function buildSurfaceProxy(opts) {
           }
           return opts.resolveCallTarget(segments);
         }
-        const { segments: argSegs } = paths.canonicalizePath(arg);
+        const { segments: argSegs } = devtoolsShared.canonicalizePath(arg);
         return opts.resolveCallTarget(argSegs);
       },
       get(_, key) {
@@ -1382,14 +1406,14 @@ function buildErrorsProxy(state) {
       const merged = [];
       if (isContainerSelfAccess) {
         const containerPath = path.slice(0, -1);
-        const containerKey = paths.canonicalizePath(containerPath).key;
-        const literalKey = paths.canonicalizePath(path).key;
+        const containerKey = devtoolsShared.canonicalizePath(containerPath).key;
+        const literalKey = devtoolsShared.canonicalizePath(path).key;
         const active2 = hasAtPath(state.form.value, containerPath);
         collectAtKey(containerKey, active2, merged);
         if (literalKey !== containerKey) collectAtKey(literalKey, active2, merged);
         return merged;
       }
-      const { key } = paths.canonicalizePath(path);
+      const { key } = devtoolsShared.canonicalizePath(path);
       const active = hasAtPath(state.form.value, path);
       collectAtKey(key, active, merged);
       return merged;
@@ -1412,17 +1436,15 @@ function buildErrorsProxy(state) {
     // shared `aggregateErrorsAt` helper that `form.meta.errors` and
     // `form.fields(path).errors` also use, so the surfaces never drift.
     //
-    // The root is the one carve-out. An EXPLICIT root path
-    // (`errors([])`) returns ONLY the global `[]` bucket (root
-    // `.refine()`, hydration failures, `setErrors`) via
-    // `getErrorsForPath`, giving consumers a dedicated channel for
-    // global messages undiluted by field errors. The no-arg `errors()`
-    // instead resolves the FULL aggregate through `resolveRootCall`
-    // below (identical to `meta.errors`).
-    resolveCallTarget: (path) => path.length === 0 ? state.getErrorsForPath([]) : aggregateErrorsAt(state, path),
+    // The root is uniform with every other path: `errors([])` is the
+    // subtree aggregate at `[]`, which is the whole form, identical to
+    // the no-arg `errors()` and to `meta.errors`. The root `[]` bucket
+    // alone (root `.refine()`, hydration failures, path-less
+    // `setErrors`) is read through `meta.ownErrors` / `meta.firstOwnError`,
+    // the dedicated own-bucket accessor, not a call-form carve-out.
+    resolveCallTarget: (path) => aggregateErrorsAt(state, path),
     // No-arg `errors()` = the whole-form aggregate, matching
-    // `meta.errors`. Distinct from `errors([])` (global bucket only);
-    // see `resolveCallTarget`.
+    // `meta.errors` and `errors([])`. All three are the same aggregate.
     resolveRootCall: () => aggregateErrorsAt(state, []),
     // Enumeration unions the live form-data keys at this path with the
     // first-child segments drawn from every error store. Without the
@@ -1455,10 +1477,10 @@ function errorAwareContainerKeys(state, segments) {
   const walk = (store, applyActivePathFilter) => {
     for (const [pathKey, errors] of store) {
       if (errors.length === 0) continue;
-      const decoded = paths.segmentsForPathKey(pathKey);
+      const decoded = devtoolsShared.segmentsForPathKey(pathKey);
       if (decoded === null) continue;
       if (decoded.length <= segments.length) continue;
-      if (!paths.isPathPrefix(segments, decoded)) continue;
+      if (!devtoolsShared.isPathPrefix(segments, decoded)) continue;
       if (applyActivePathFilter && !hasAtPath(formValue, decoded)) continue;
       const nextSeg = decoded[segments.length];
       keys.add(typeof nextSeg === "number" ? String(nextSeg) : nextSeg);
@@ -1475,10 +1497,10 @@ function materializeErrors(state, containerSegments) {
   const collect = (store, applyActivePathFilter) => {
     entries: for (const [pathKey, errors] of store) {
       if (errors.length === 0) continue;
-      const fullPath = paths.segmentsForPathKey(pathKey);
+      const fullPath = devtoolsShared.segmentsForPathKey(pathKey);
       if (fullPath === null) continue;
       if (fullPath.length === 0) {
-        if (containerSegments.length === 0) placeAt(tree, [paths.ROOT_PATH_KEY], errors);
+        if (containerSegments.length === 0) placeAt(tree, [devtoolsShared.ROOT_PATH_KEY], errors);
         continue;
       }
       if (fullPath.length < containerSegments.length) continue;
@@ -1529,12 +1551,12 @@ function placeAt(tree, path, errors) {
 
 function buildFieldArrayApi(state) {
   function readArray(path) {
-    const segments = paths.canonicalizePath(path).segments;
+    const segments = devtoolsShared.canonicalizePath(path).segments;
     const current = state.getValueAtPath(segments);
     return Array.isArray(current) ? current.slice() : [];
   }
   function writeArray(path, next, arrayOp) {
-    const { segments } = paths.canonicalizePath(path);
+    const { segments } = devtoolsShared.canonicalizePath(path);
     const meta = {
       ...arrayOp !== void 0 ? { arrayOp } : {}
     };
@@ -1606,6 +1628,7 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "elements",
   "updatedAt",
   "errors",
+  "ownErrors",
   "validating",
   "valid",
   "transforming",
@@ -1617,6 +1640,7 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "showSuccess",
   "showIdle",
   "firstError",
+  "firstOwnError",
   "path",
   "id",
   "aria",
@@ -1686,7 +1710,7 @@ function buildFieldStateProxy(state, formInstanceId, getFormMetaBase, options) {
       // module), which would violate the documented "writes are
       // ignored" contract. Mirrors `values-proxy` / `wizard-statuses-proxy`.
       set: (_, key) => {
-        if (paths.__DEV__) {
+        if (devtoolsShared.__DEV__) {
           console.warn(
             `[attaform] form.fields(path) is read-only \u2014 write to "${String(key)}" was ignored. Use form.setValue / the directive / field-array helpers instead.`
           );
@@ -1694,7 +1718,7 @@ function buildFieldStateProxy(state, formInstanceId, getFormMetaBase, options) {
         return true;
       },
       deleteProperty: (_, key) => {
-        if (paths.__DEV__) {
+        if (devtoolsShared.__DEV__) {
           console.warn(
             `[attaform] form.fields(path) is read-only \u2014 delete of "${String(key)}" was ignored.`
           );
@@ -1702,7 +1726,7 @@ function buildFieldStateProxy(state, formInstanceId, getFormMetaBase, options) {
         return true;
       },
       defineProperty: (_, key) => {
-        if (paths.__DEV__) {
+        if (devtoolsShared.__DEV__) {
           console.warn(
             `[attaform] form.fields(path) is read-only \u2014 define of "${String(key)}" was ignored.`
           );
@@ -1757,7 +1781,33 @@ function walk$1(value, basePath, schema, snapshotFieldStateAt) {
   return result;
 }
 
-const warnedNoScopeStores = paths.__DEV__ ? /* @__PURE__ */ new WeakSet() : null;
+const warnedNoScopeStores = devtoolsShared.__DEV__ ? /* @__PURE__ */ new WeakSet() : null;
+function isErrorInputLike(value) {
+  if (value instanceof Error) return true;
+  if (typeof value !== "object" || value === null) return false;
+  const shape = value;
+  return typeof shape.message === "string" && shape.message.length > 0 || Array.isArray(shape.path);
+}
+function deriveSubmitErrors(err, formKey) {
+  if (Array.isArray(err) && err.length > 0 && err.every(isErrorInputLike)) {
+    return {
+      entries: err.map(
+        (item) => devtoolsShared.normalizeErrorInput(item, void 0, formKey, AttaformErrorCode.SubmitError)
+      ),
+      messageless: false
+    };
+  }
+  if (isErrorInputLike(err)) {
+    return {
+      entries: [devtoolsShared.normalizeErrorInput(err, void 0, formKey, AttaformErrorCode.SubmitError)],
+      messageless: false
+    };
+  }
+  return {
+    entries: [devtoolsShared.normalizeErrorInput({}, void 0, formKey, AttaformErrorCode.SubmitError)],
+    messageless: true
+  };
+}
 function buildProcessForm(state, formInstanceId, options = {}) {
   const invalidPolicy = options.onInvalidSubmit ?? "focus-first-error";
   function validate(pathInput) {
@@ -1809,7 +1859,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
     });
     if (vue.getCurrentScope() !== void 0) {
       vue.onScopeDispose(stop);
-    } else if (paths.__DEV__ && warnedNoScopeStores !== null && !warnedNoScopeStores.has(state)) {
+    } else if (devtoolsShared.__DEV__ && warnedNoScopeStores !== null && !warnedNoScopeStores.has(state)) {
       warnedNoScopeStores.add(state);
       console.warn(
         "[attaform] validate() called outside a Vue effect scope; its reactive watcher will leak until the form is garbage-collected. Fix: call validate() inside setup() / a child component, or wrap the call in `effectScope().run(...)`."
@@ -1926,7 +1976,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
             try {
               await onError(merged.errors);
             } catch (cause) {
-              throw new paths.SubmitErrorHandlerError("User-provided onError threw", { cause });
+              throw new devtoolsShared.SubmitErrorHandlerError("User-provided onError threw", { cause });
             }
           }
           return;
@@ -1939,13 +1989,6 @@ function buildProcessForm(state, formInstanceId, options = {}) {
           if (state.submissionGeneration.value === genAtEntry) {
             applyInvalidSubmitPolicy(state, formInstanceId, invalidPolicy);
           }
-          if (onError !== void 0) {
-            try {
-              await onError(Array.from(state.userErrors.values()).flat());
-            } catch (cause) {
-              throw new paths.SubmitErrorHandlerError("User-provided onError threw", { cause });
-            }
-          }
           return;
         }
         if (state.submissionGeneration.value === genAtEntry) {
@@ -1954,7 +1997,26 @@ function buildProcessForm(state, formInstanceId, options = {}) {
         state.emitSubmitSuccess();
       } catch (err) {
         if (state.submissionGeneration.value === genAtEntry) {
-          state.submitError.value = paths.toError(err);
+          state.submitError.value = devtoolsShared.toError(err);
+          if (!(err instanceof devtoolsShared.SubmitErrorHandlerError)) {
+            const { entries, messageless } = deriveSubmitErrors(err, state.formKey);
+            const byPath = /* @__PURE__ */ new Map();
+            for (const entry of entries) {
+              const { key } = devtoolsShared.canonicalizePath(entry.path);
+              const bucket = byPath.get(key);
+              if (bucket === void 0) byPath.set(key, { segments: entry.path, entries: [entry] });
+              else bucket.entries.push(entry);
+            }
+            for (const { segments, entries: bucket } of byPath.values()) {
+              state.setUserErrorsForPath(segments, bucket);
+            }
+            applyInvalidSubmitPolicy(state, formInstanceId, invalidPolicy);
+            if (devtoolsShared.__DEV__ && messageless) {
+              console.warn(
+                "[attaform] handleSubmit callback threw a non-Error value; throw an Error or a ValidationError ({ message, path? }) so the failure surfaces with a usable message."
+              );
+            }
+          }
         }
       } finally {
         if (!validationSettled) {
@@ -1972,7 +2034,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
   return { validate, validateAsync, parse, handleSubmit };
 }
 function toSegments(pathInput) {
-  return paths.canonicalizePath(pathInput).segments;
+  return devtoolsShared.canonicalizePath(pathInput).segments;
 }
 function settled(response) {
   if (response.success) {
@@ -1996,7 +2058,7 @@ function collectScopedBlankErrors(state, scope) {
   const errors = [];
   for (const [pathKey, entries] of derived) {
     if (scope !== void 0) {
-      const segments = paths.segmentsForPathKey(pathKey);
+      const segments = devtoolsShared.segmentsForPathKey(pathKey);
       if (segments === null) continue;
       if (!pathStartsWith(segments, scope)) continue;
     }
@@ -2027,7 +2089,7 @@ function applyInvalidSubmitPolicy(state, formInstanceId, policy) {
   target.element.focus({ preventScroll: true, focusVisible: true });
 }
 
-const warnedRejections = paths.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+const warnedRejections = devtoolsShared.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
 function shouldWarnOnce$1(store, key) {
   if (warnedRejections === null) return false;
   let set = warnedRejections.get(store);
@@ -2101,7 +2163,7 @@ function walk(schema, store, path, value) {
   return true;
 }
 function reportRejection(store, path, kind, accepted) {
-  if (!paths.__DEV__) return;
+  if (!devtoolsShared.__DEV__) return;
   const dotted = path.map((s) => String(s)).join(".") || "(root)";
   const key = `${dotted}::${kind}`;
   if (!shouldWarnOnce$1(store, key)) return;
@@ -2175,13 +2237,13 @@ function indexRules(rules) {
   for (const entry of rules) {
     const candidate = entry;
     if (candidate === null || typeof candidate !== "object" || typeof candidate.transform !== "function") {
-      if (paths.__DEV__) {
+      if (devtoolsShared.__DEV__) {
         console.warn("[attaform] coercion entry missing or invalid `transform` \u2014 skipped.");
       }
       continue;
     }
     const key = `${entry.input}->${entry.output}`;
-    if (idx.has(key) && paths.__DEV__) {
+    if (idx.has(key) && devtoolsShared.__DEV__) {
       console.warn(`[attaform] duplicate coercion rule for '${key}' \u2014 last entry wins.`);
     }
     idx.set(key, entry);
@@ -2210,7 +2272,7 @@ function pickScalarTarget(accepted) {
   if (accepted.has("bigint")) return "bigint";
   return null;
 }
-const warnedCoerce = paths.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+const warnedCoerce = devtoolsShared.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
 const sharedWarnStore = {};
 function shouldWarnOnce(key) {
   if (warnedCoerce === null) return false;
@@ -2235,7 +2297,7 @@ function coerceScalar(value, accepted, index) {
   try {
     result = entry.transform(value);
   } catch (err) {
-    if (paths.__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::throw`)) {
+    if (devtoolsShared.__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::throw`)) {
       console.warn(
         `[attaform] coercion '${entry.input}->${entry.output}' threw \u2014 write passes through.`,
         err
@@ -2246,7 +2308,7 @@ function coerceScalar(value, accepted, index) {
   if (!result.coerced) return value;
   const returnedKind = slimKindOf(result.value);
   if (returnedKind !== entry.output) {
-    if (paths.__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::wrong-kind:${returnedKind}`)) {
+    if (devtoolsShared.__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::wrong-kind:${returnedKind}`)) {
       console.warn(
         `[attaform] coercion '${entry.input}->${entry.output}' produced a ${returnedKind} \u2014 write passes through.`
       );
@@ -2254,7 +2316,7 @@ function coerceScalar(value, accepted, index) {
     return value;
   }
   if (entry.output === "number" && !Number.isFinite(result.value)) {
-    if (paths.__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::nan`)) {
+    if (devtoolsShared.__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::nan`)) {
       console.warn(
         `[attaform] coercion '${entry.input}->${entry.output}' produced a non-finite number \u2014 write passes through.`
       );
@@ -2297,7 +2359,7 @@ function coerceValue(value, accepted, elementAccepted, index) {
 
 const warnedMultiRootHosts = /* @__PURE__ */ new Set();
 const EMPTY_TRANSFORMS = Object.freeze([]);
-const attaformListenersSymbol = Symbol.for("attaform:focus-listeners");
+const attaformListenersSymbol = /* @__PURE__ */ Symbol.for("attaform:focus-listeners");
 function attachFocusListeners(state, segments, element, instanceMeta) {
   const target = element;
   if (target[attaformListenersSymbol] !== void 0) return;
@@ -2332,7 +2394,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
   };
   const lastTypedFormByPath = /* @__PURE__ */ new Map();
   return function register(pathInput, options) {
-    const { segments, key: pathKey } = paths.canonicalizePath(pathInput);
+    const { segments, key: pathKey } = devtoolsShared.canonicalizePath(pathInput);
     const innerRef = vue.computed(() => state.getValueAtPath(segments));
     let lastTypedForm = lastTypedFormByPath.get(pathKey);
     if (lastTypedForm === void 0) {
@@ -2389,7 +2451,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         state.markInteracted(segments);
       },
       registerElement: (element) => {
-        if (!paths.INTERACTIVE_TAG_NAMES.has(element.tagName)) return;
+        if (!devtoolsShared.INTERACTIVE_TAG_NAMES.has(element.tagName)) return;
         const added = state.registerElement(segments, element, formInstanceId);
         if (added) attachFocusListeners(state, segments, element, instanceMeta);
       },
@@ -2403,7 +2465,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       setValueFromHost: (value) => {
         state.markInteracted(segments);
         const accepted = state.setValueAtPath(segments, value, withInstanceMeta(void 0));
-        if (paths.__DEV__) {
+        if (devtoolsShared.__DEV__) {
           const dedupeKey = `${formInstanceId}:${pathKey}`;
           const isWired = () => (state.elements.get(pathKey)?.elements.size ?? 0) > 0 || state.getFieldRecord(segments)?.connected === true;
           if (!warnedMultiRootHosts.has(dedupeKey) && !isWired()) {
@@ -2487,7 +2549,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
   };
 }
 
-const unset = Symbol.for("attaform/unset");
+const unset = /* @__PURE__ */ Symbol.for("attaform/unset");
 function isUnset(value) {
   return value === unset;
 }
@@ -2560,10 +2622,10 @@ function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
   }
   return input;
 }
-function walkUnspecified(slim, segments, paths$1) {
+function walkUnspecified(slim, segments, paths) {
   if (isPrimitiveOrEmpty(slim)) {
     if (isSlimNumericPrimitive(slim)) {
-      paths$1.push(paths.canonicalizePath(segments).key);
+      paths.push(devtoolsShared.canonicalizePath(segments).key);
     }
     return slim;
   }
@@ -2577,7 +2639,7 @@ function walkUnspecified(slim, segments, paths$1) {
       safeAssign(
         out,
         key,
-        walkUnspecified(slim[key], [...segments, key], paths$1)
+        walkUnspecified(slim[key], [...segments, key], paths)
       );
     }
     return out;
@@ -2605,27 +2667,27 @@ function blankForKind(slimDefault) {
   if (slimDefault === null) return null;
   return void 0;
 }
-function expandUnsetAt(segments, schema, paths$1) {
+function expandUnsetAt(segments, schema, paths) {
   const du = schema.getUnionDiscriminatorAtPath(segments);
   if (du !== void 0) {
     const discPath = [...segments, du.discriminatorKey];
     const discSlim = schema.getEmptyValueAtPath(discPath);
-    paths$1.push(paths.canonicalizePath(discPath).key);
+    paths.push(devtoolsShared.canonicalizePath(discPath).key);
     return { [du.discriminatorKey]: blankForKind(discSlim) };
   }
   const slim = schema.getEmptyValueAtPath(segments);
   if (isPrimitiveOrEmpty(slim)) {
-    paths$1.push(paths.canonicalizePath(segments).key);
+    paths.push(devtoolsShared.canonicalizePath(segments).key);
     return slim;
   }
   if (isOpaqueLeaf(slim)) {
-    paths$1.push(paths.canonicalizePath(segments).key);
+    paths.push(devtoolsShared.canonicalizePath(segments).key);
     return slim;
   }
   if (Array.isArray(slim)) return slim;
   const result = {};
   for (const key of Object.keys(slim)) {
-    result[key] = expandUnsetAt([...segments, key], schema, paths$1);
+    result[key] = expandUnsetAt([...segments, key], schema, paths);
   }
   return result;
 }
@@ -2729,7 +2791,7 @@ function buildValuesProxy(form) {
     // (`getAtPath`), so `form.values('a.hasOwnProperty')` resolves the
     // stored value. Per-level reads still propagate Vue's tracking for
     // ordinary keys.
-    resolveCall: (arg) => getAtPath(inner.value, paths.canonicalizePath(arg).segments),
+    resolveCall: (arg) => getAtPath(inner.value, devtoolsShared.canonicalizePath(arg).segments),
     ownKeys: () => Reflect.ownKeys(inner.value),
     hasKey: (key) => Reflect.has(inner.value, key),
     describeKey: (key) => {
@@ -2752,9 +2814,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
     if (instanceMeta === void 0) return meta;
     return meta === void 0 ? { instance: instanceMeta } : { ...meta, instance: instanceMeta };
   };
-  const reMarkBlanksAfterSubstitution = (paths$1) => {
-    for (const pathKey of paths$1) {
-      const blankSegments = paths.segmentsForPathKey(pathKey);
+  const reMarkBlanksAfterSubstitution = (paths) => {
+    for (const pathKey of paths) {
+      const blankSegments = devtoolsShared.segmentsForPathKey(pathKey);
       if (blankSegments === null) continue;
       state.setValueAtPath(
         blankSegments,
@@ -2767,8 +2829,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
     let rollup;
     const rootBase = () => rollup ?? (rollup = buildContainerFieldStateBase(
       state,
-      paths.ROOT_PATH,
-      paths.ROOT_PATH_KEY,
+      devtoolsShared.ROOT_PATH,
+      devtoolsShared.ROOT_PATH_KEY,
       formInstanceId
     ).base);
     return {
@@ -2816,6 +2878,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
       get errors() {
         return rootBase().errors;
       },
+      get ownErrors() {
+        return rootBase().ownErrors;
+      },
       get validating() {
         return rootBase().validating;
       },
@@ -2905,7 +2970,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const validateAsync = (pathInput) => validateAsyncBuilt(pathInput);
   const parse = (pathInput) => parseBuilt(pathInput);
   function pathToRef(pathInput) {
-    const segments = paths.canonicalizePath(pathInput).segments;
+    const segments = devtoolsShared.canonicalizePath(pathInput).segments;
     return vue.computed(() => getAtPath(state.form.value, segments));
   }
   function setValueImpl(pathOrValue, maybeValue) {
@@ -2923,7 +2988,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
       reMarkBlanksAfterSubstitution(walked2.paths);
       return true;
     }
-    const segments = paths.canonicalizePath(pathOrValue).segments;
+    const segments = devtoolsShared.canonicalizePath(pathOrValue).segments;
     const writeUnsetAt = () => {
       const last = segments.length > 0 ? segments[segments.length - 1] : void 0;
       if (typeof last === "string") {
@@ -2941,14 +3006,14 @@ function buildFormApi(state, formInstanceId, options = {}) {
         state.schema,
         blankPaths
       );
-      const segmentsKey = paths.canonicalizePath(segments).key;
+      const segmentsKey = devtoolsShared.canonicalizePath(segments).key;
       if (blankPaths.length === 1 && blankPaths[0] === segmentsKey) {
         return state.setValueAtPath(segments, expanded, writeMeta({ blank: true }));
       }
       const ok2 = state.setValueAtPath(segments, expanded, writeMeta());
       if (!ok2) return false;
       for (const pathKey of blankPaths) {
-        const blankSegments = paths.segmentsForPathKey(pathKey);
+        const blankSegments = devtoolsShared.segmentsForPathKey(pathKey);
         if (blankSegments === null) continue;
         state.setValueAtPath(
           blankSegments,
@@ -2979,28 +3044,6 @@ function buildFormApi(state, formInstanceId, options = {}) {
     return true;
   }
   const errorsProxy = buildErrorsProxy(state);
-  function normalizeErrorInput(item, scope) {
-    if (item instanceof Error) {
-      return {
-        message: item.message.length > 0 ? item.message : "Unknown error",
-        path: scope !== void 0 ? [...scope] : [],
-        formKey: state.formKey,
-        code: AttaformErrorCode.UserError
-      };
-    }
-    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] : [],
-      formKey: state.formKey,
-      code: typeof item.code === "string" && item.code.length > 0 ? item.code : AttaformErrorCode.UserError
-    };
-    if (item.data !== void 0) entry.data = item.data;
-    return entry;
-  }
-  function normalizeErrorInputs(input, scope) {
-    const items = Array.isArray(input) ? input : [input];
-    return items.map((item) => normalizeErrorInput(item, scope));
-  }
   function flattenUserErrors() {
     const all = [];
     for (const errs of state.userErrors.values()) all.push(...errs);
@@ -3009,15 +3052,20 @@ function buildFormApi(state, formInstanceId, options = {}) {
   function setErrors(arg1, arg2) {
     const isScoped = arguments.length >= 2 && (typeof arg1 === "string" || Array.isArray(arg1));
     if (isScoped) {
-      const { segments, key } = paths.canonicalizePath(arg1);
+      const { segments, key } = devtoolsShared.canonicalizePath(arg1);
       const input2 = arg2;
       const resolved2 = typeof input2 === "function" ? input2((state.userErrors.get(key) ?? []).slice()) : input2;
-      state.setUserErrorsForPath(segments, normalizeErrorInputs(resolved2, segments));
+      state.setUserErrorsForPath(
+        segments,
+        devtoolsShared.normalizeErrorInputs(resolved2, segments, state.formKey, AttaformErrorCode.UserError)
+      );
       return;
     }
     const input = arg1;
     const resolved = typeof input === "function" ? input(flattenUserErrors()) : input;
-    state.setAllUserErrors(normalizeErrorInputs(resolved, void 0));
+    state.setAllUserErrors(
+      devtoolsShared.normalizeErrorInputs(resolved, void 0, state.formKey, AttaformErrorCode.UserError)
+    );
   }
   function clearErrors(path) {
     if (path === void 0) {
@@ -3025,7 +3073,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
       state.clearUserErrors();
       return;
     }
-    const segments = paths.canonicalizePath(path).segments;
+    const segments = devtoolsShared.canonicalizePath(path).segments;
     state.clearSchemaErrors(segments);
     state.clearUserErrors(segments);
   }
@@ -3112,6 +3160,17 @@ function buildFormApi(state, formInstanceId, options = {}) {
       // keep the explicit form-level computation for the gate.
       valid,
       errors: metaErrors,
+      // The root `[]` bucket alone: form-level errors from a root
+      // `.refine()` or a path-less `setErrors`, excluding every field error
+      // that `errors` (the whole-form aggregate) rolls up. This is the
+      // banner accessor. Mirrors `rootFieldState` rather than taking a
+      // dedicated computed: `getFieldState([])` routes a container root
+      // through `getErrorsForPath([])` and a primitive root through its own
+      // bucket, and both equal the root bucket, so the root field state is
+      // already the single source of truth.
+      get ownErrors() {
+        return rootFieldState.value.ownErrors;
+      },
       // Whole-form transforming mirrors the global `activeTransforms`
       // counter ORed with any per-leaf transform in flight (the root
       // rollup), exactly as `validating` composes its lifecycle and
@@ -3150,6 +3209,11 @@ function buildFormApi(state, formInstanceId, options = {}) {
       get firstError() {
         return rootFieldState.value.firstError;
       },
+      // `ownErrors[0]`: the form's first top-level error. Pair it with
+      // `ownErrors` for the form-level banner.
+      get firstOwnError() {
+        return rootFieldState.value.firstOwnError;
+      },
       get path() {
         return rootFieldState.value.path;
       },
@@ -3213,7 +3277,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     }
   };
   const resetField = (pathInput) => {
-    const segments = paths.canonicalizePath(pathInput).segments;
+    const segments = devtoolsShared.canonicalizePath(pathInput).segments;
     state.resetField(segments);
   };
   function clear(pathInput) {
@@ -3223,7 +3287,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     return setValueImpl(pathInput, unset);
   }
   function touch(pathInput) {
-    const segments = pathInput === void 0 ? paths.ROOT_PATH : paths.canonicalizePath(pathInput).segments;
+    const segments = pathInput === void 0 ? devtoolsShared.ROOT_PATH : devtoolsShared.canonicalizePath(pathInput).segments;
     state.touchAtPath(segments);
   }
   const focusFirstError = (options2) => {
@@ -3244,26 +3308,26 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const fieldArrays = buildFieldArrayApi(state);
   const blankPathsView = vue.computed(() => {
     const keys = /* @__PURE__ */ new Set();
-    const paths$1 = [];
+    const paths = [];
     for (const pk of state.blankPaths) {
       keys.add(pk);
-      const segs = paths.segmentsForPathKey(pk);
-      if (segs !== null) paths$1.push(segs);
+      const segs = devtoolsShared.segmentsForPathKey(pk);
+      if (segs !== null) paths.push(segs);
     }
-    Object.freeze(paths$1);
+    Object.freeze(paths);
     const view = {
       get size() {
         return keys.size;
       },
       has(input) {
-        const { key } = paths.canonicalizePath(input);
+        const { key } = devtoolsShared.canonicalizePath(input);
         return keys.has(key);
       },
       values() {
-        return paths$1;
+        return paths;
       },
       [Symbol.iterator]() {
-        return paths$1[Symbol.iterator]();
+        return paths[Symbol.iterator]();
       }
     };
     return Object.freeze(view);
@@ -3286,7 +3350,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const callTerminal = fieldStateProxy;
   const EMPTY_FIELD_LIST = Object.freeze([]);
   function list(path) {
-    const { segments } = paths.canonicalizePath(path);
+    const { segments } = devtoolsShared.canonicalizePath(path);
     const value = state.getValueAtPath(segments);
     if (!Array.isArray(value)) return EMPTY_FIELD_LIST;
     const out = new Array(value.length);
@@ -3295,7 +3359,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
   }
   const EMPTY_FIELD_RECORD = Object.freeze({});
   function record(path) {
-    const segments = path === void 0 ? [] : paths.canonicalizePath(path).segments;
+    const segments = path === void 0 ? [] : devtoolsShared.canonicalizePath(path).segments;
     const value = state.getValueAtPath(segments);
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
       return EMPTY_FIELD_RECORD;
@@ -3393,6 +3457,33 @@ function buildFormApi(state, formInstanceId, options = {}) {
   return api;
 }
 
+function captureUserCallSite() {
+  const raw = new Error().stack;
+  if (typeof raw !== "string") return void 0;
+  const lines = raw.split("\n");
+  for (let i = 1; i < lines.length; i++) {
+    const frame = lines[i];
+    if (frame === void 0) continue;
+    if (/attaform[/-]forms?/i.test(frame)) continue;
+    if (/\bforms\.[A-Za-z0-9_-]+\.m?js\b/.test(frame)) continue;
+    const trimmed = frame.trim();
+    if (trimmed.length === 0) continue;
+    return shortenSourceFrame(trimmed);
+  }
+  return void 0;
+}
+function shortenSourceFrame(frame) {
+  const match = /(?:^|\s|\()([^\s()]+):(\d+):\d+\)?$/.exec(frame);
+  if (match === null) return frame;
+  const [, urlOrPath, line] = match;
+  if (urlOrPath === void 0 || line === void 0) return frame;
+  let path = urlOrPath;
+  path = path.replace(/^[a-z]+:\/\/[^/]+\//i, "");
+  path = path.replace(/^_nuxt\//, "");
+  path = path.replace(/^\//, "");
+  return `(${path}:${line})`;
+}
+
 const IDLE = Object.freeze({ display: "idle" });
 const MAX_DELAY = 2147483647;
 function createDisplayEngine(ssr) {
@@ -3498,7 +3589,7 @@ function walkDuStubs(schema, value, path, warned) {
     const discValue = rec[du.discriminatorKey];
     if (discValue !== void 0 && !du.isVariantSelected(discValue)) {
       const isKindBlank = discValue === "" || discValue === 0 || discValue === 0n || discValue === false || discValue === null;
-      if (!isKindBlank && warned !== void 0 && paths.__DEV__) {
+      if (!isKindBlank && warned !== void 0 && devtoolsShared.__DEV__) {
         const dotted = path.map((s) => String(s)).join(".") || "(root)";
         const key = `${dotted}::${String(discValue)}`;
         if (!warned.has(key)) {
@@ -3524,9 +3615,9 @@ function createVariantMemory() {
   const memory = /* @__PURE__ */ new Map();
   function clearAtArrayIndices(arrayPath, indexFilter) {
     for (const memKey of [...memory.keys()]) {
-      const segs = paths.segmentsForPathKey(memKey);
+      const segs = devtoolsShared.segmentsForPathKey(memKey);
       if (segs === null) continue;
-      if (!paths.isPathPrefix(arrayPath, segs)) continue;
+      if (!devtoolsShared.isPathPrefix(arrayPath, segs)) continue;
       if (segs.length <= arrayPath.length) continue;
       const idxSeg = segs[arrayPath.length];
       if (typeof idxSeg !== "number") continue;
@@ -3539,9 +3630,9 @@ function createVariantMemory() {
     },
     clearUnderPath(parentPath) {
       for (const memKey of [...memory.keys()]) {
-        const segs = paths.segmentsForPathKey(memKey);
+        const segs = devtoolsShared.segmentsForPathKey(memKey);
         if (segs === null) continue;
-        if (paths.isPathPrefix(parentPath, segs)) memory.delete(memKey);
+        if (devtoolsShared.isPathPrefix(parentPath, segs)) memory.delete(memKey);
       }
     },
     applyArrayOp(arrayPath, op) {
@@ -3634,11 +3725,11 @@ function createArrayIdentity(getArrayLength) {
     tokenAt(arraySegs, index) {
       const len = getArrayLength(arraySegs);
       if (index < 0 || index >= len) return "";
-      const ids = ensure(paths.canonicalizePath(arraySegs).key, len);
+      const ids = ensure(devtoolsShared.canonicalizePath(arraySegs).key, len);
       return ids[index] ?? "";
     },
     applyOp(arraySegs, op) {
-      const arrayKey = paths.canonicalizePath(arraySegs).key;
+      const arrayKey = devtoolsShared.canonicalizePath(arraySegs).key;
       const postLen = getArrayLength(arraySegs);
       const preLen = op.kind === "insert" ? postLen - 1 : op.kind === "remove" ? postLen + 1 : postLen;
       const ids = ensure(arrayKey, Math.max(0, preLen));
@@ -3671,9 +3762,9 @@ function createArrayIdentity(getArrayLength) {
         const idxPos = arrayPath.length;
         const snapshots = [];
         for (const [key, value] of store) {
-          const segments = paths.segmentsForPathKey(key);
+          const segments = devtoolsShared.segmentsForPathKey(key);
           if (segments === null) continue;
-          if (!paths.isPathPrefix(arrayPath, segments)) continue;
+          if (!devtoolsShared.isPathPrefix(arrayPath, segments)) continue;
           if (segments.length <= idxPos) continue;
           const idxSeg = segments[idxPos];
           if (typeof idxSeg !== "number") continue;
@@ -3683,33 +3774,33 @@ function createArrayIdentity(getArrayLength) {
           snapshots.push({ segments: [...segments], index: idxSeg, value });
         }
         if (snapshots.length === 0) return;
-        for (const snap of snapshots) store.delete(paths.canonicalizePath(snap.segments).key);
+        for (const snap of snapshots) store.delete(devtoolsShared.canonicalizePath(snap.segments).key);
         for (const snap of snapshots) {
           const target = remap.moved.get(snap.index);
           if (target === void 0) continue;
           const relocated = snap.segments.slice();
           relocated[idxPos] = target;
-          store.set(paths.canonicalizePath(relocated).key, snap.value);
+          store.set(devtoolsShared.canonicalizePath(relocated).key, snap.value);
         }
       };
       relocate(tokens);
       relocate(baselines);
     },
     realign(arraySegs) {
-      ensure(paths.canonicalizePath(arraySegs).key, getArrayLength(arraySegs));
+      ensure(devtoolsShared.canonicalizePath(arraySegs).key, getArrayLength(arraySegs));
     },
     hasStructuralChangeUnder(prefix) {
       for (const arrayKey of tokens.keys()) {
         if (orderPristineForKey(arrayKey)) continue;
-        const segs = paths.segmentsForPathKey(arrayKey);
+        const segs = devtoolsShared.segmentsForPathKey(arrayKey);
         if (segs === null) continue;
-        if (paths.isPathPrefix(prefix, segs)) return true;
+        if (devtoolsShared.isPathPrefix(prefix, segs)) return true;
       }
       return false;
     },
     rebaselineAll() {
       for (const arrayKey of [...tokens.keys()]) {
-        const segs = paths.segmentsForPathKey(arrayKey);
+        const segs = devtoolsShared.segmentsForPathKey(arrayKey);
         if (segs === null) continue;
         const ids = ensure(arrayKey, getArrayLength(segs));
         baselines.set(arrayKey, [...ids]);
@@ -3763,9 +3854,9 @@ function changedIndices(remap) {
   return changed;
 }
 function elementIndexUnder(arrayPath, key, idxPos) {
-  const segments = paths.segmentsForPathKey(key);
+  const segments = devtoolsShared.segmentsForPathKey(key);
   if (segments === null) return null;
-  if (!paths.isPathPrefix(arrayPath, segments)) return null;
+  if (!devtoolsShared.isPathPrefix(arrayPath, segments)) return null;
   if (segments.length <= idxPos) return null;
   const index = segments[idxPos];
   return typeof index === "number" ? index : null;
@@ -3777,16 +3868,16 @@ function migrateMapSubtree(map, arrayPath, remap, rewriteValue) {
     const index = elementIndexUnder(arrayPath, key, idxPos);
     if (index === null) continue;
     if (!remap.moved.has(index) && !remap.vacated.has(index)) continue;
-    snapshots.push({ segments: [...paths.segmentsForPathKey(key)], index, value });
+    snapshots.push({ segments: [...devtoolsShared.segmentsForPathKey(key)], index, value });
   }
   if (snapshots.length === 0) return;
-  for (const snap of snapshots) map.delete(paths.canonicalizePath(snap.segments).key);
+  for (const snap of snapshots) map.delete(devtoolsShared.canonicalizePath(snap.segments).key);
   for (const snap of snapshots) {
     const target = remap.moved.get(snap.index);
     if (target === void 0) continue;
     const relocated = snap.segments.slice();
     relocated[idxPos] = target;
-    map.set(paths.canonicalizePath(relocated).key, rewriteValue(snap.value, relocated));
+    map.set(devtoolsShared.canonicalizePath(relocated).key, rewriteValue(snap.value, relocated));
   }
 }
 function migrateSetSubtree(set, arrayPath, remap) {
@@ -3796,16 +3887,16 @@ function migrateSetSubtree(set, arrayPath, remap) {
     const index = elementIndexUnder(arrayPath, key, idxPos);
     if (index === null) continue;
     if (!remap.moved.has(index) && !remap.vacated.has(index)) continue;
-    snapshots.push({ segments: [...paths.segmentsForPathKey(key)], index });
+    snapshots.push({ segments: [...devtoolsShared.segmentsForPathKey(key)], index });
   }
   if (snapshots.length === 0) return;
-  for (const snap of snapshots) set.delete(paths.canonicalizePath(snap.segments).key);
+  for (const snap of snapshots) set.delete(devtoolsShared.canonicalizePath(snap.segments).key);
   for (const snap of snapshots) {
     const target = remap.moved.get(snap.index);
     if (target === void 0) continue;
     const relocated = snap.segments.slice();
     relocated[idxPos] = target;
-    set.add(paths.canonicalizePath(relocated).key);
+    set.add(devtoolsShared.canonicalizePath(relocated).key);
   }
 }
 
@@ -3855,7 +3946,7 @@ function createArrayBookkeeping(deps) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     diffAndApply(void 0, getAtPath(form.value, elementPath), elementPath, (patch) => {
       if (patch.kind !== "added") return;
-      const { key } = paths.canonicalizePath(patch.path);
+      const { key } = devtoolsShared.canonicalizePath(patch.path);
       if (!originals.has(key)) originals.set(key, { segments: patch.path, value: void 0 });
       touchFieldRecord(key, patch.path, { updatedAt: now });
     });
@@ -3865,9 +3956,9 @@ function createArrayBookkeeping(deps) {
     if (changed.size === 0) return;
     const idxPos = arrayPath.length;
     for (const key of [...schemaErrors.keys()]) {
-      const segs = paths.segmentsForPathKey(key);
+      const segs = devtoolsShared.segmentsForPathKey(key);
       if (segs === null) continue;
-      if (!paths.isPathPrefix(arrayPath, segs)) continue;
+      if (!devtoolsShared.isPathPrefix(arrayPath, segs)) continue;
       if (segs.length <= idxPos) continue;
       const idx = segs[idxPos];
       if (typeof idx === "number" && changed.has(idx)) schemaErrors.delete(key);
@@ -3877,9 +3968,9 @@ function createArrayBookkeeping(deps) {
     if (remap.vacated.size === 0) return;
     const idxPos = arrayPath.length;
     for (const [key, entry] of [...fieldValidationState]) {
-      const segs = paths.segmentsForPathKey(key);
+      const segs = devtoolsShared.segmentsForPathKey(key);
       if (segs === null) continue;
-      if (!paths.isPathPrefix(arrayPath, segs)) continue;
+      if (!devtoolsShared.isPathPrefix(arrayPath, segs)) continue;
       if (segs.length <= idxPos) continue;
       const idx = segs[idxPos];
       if (typeof idx !== "number" || !remap.vacated.has(idx)) continue;
@@ -3983,13 +4074,13 @@ function isHydratedValidationErrorArray(value) {
   return true;
 }
 function warnMalformedHydration(formKey, kind, rawKey) {
-  if (!paths.__DEV__) return;
+  if (!devtoolsShared.__DEV__) return;
   console.warn(
     `[attaform] hydration: skipping malformed ${kind} entry at key '${rawKey}' on form '${formKey}'. This usually means the SSR bundle is on a different version than the client (rolling deploy / stale cache).`
   );
 }
 function isPathKeyUnder(existingKey, parentPath) {
-  const parsed = paths.segmentsForPathKey(existingKey);
+  const parsed = devtoolsShared.segmentsForPathKey(existingKey);
   if (parsed === null) return false;
   if (parsed.length <= parentPath.length) return false;
   for (let i = 0; i < parentPath.length; i++) {
@@ -4024,7 +4115,7 @@ function stripSymbolsDeep(value) {
   return mutated ? out : value;
 }
 function walkAuthoredFromConstraints(value, prefix, out) {
-  if (prefix.length > 0) out.add(paths.canonicalizePath(prefix).key);
+  if (prefix.length > 0) out.add(devtoolsShared.canonicalizePath(prefix).key);
   if (isPlainRecord(value)) {
     for (const k of Object.keys(value)) {
       walkAuthoredFromConstraints(value[k], [...prefix, k], out);
@@ -4066,7 +4157,7 @@ function walkAuthoredFromSchemaDiff(withDefaults, withoutDefaults, prefix, out)
     return;
   }
   if (!Object.is(withDefaults, withoutDefaults) && prefix.length > 0) {
-    out.add(paths.canonicalizePath(prefix).key);
+    out.add(devtoolsShared.canonicalizePath(prefix).key);
   }
 }
 function createFormStore(options) {
@@ -4116,7 +4207,7 @@ function createFormStore(options) {
       if (pathSegments.length === 0) return true;
       const value = getAtPath(form.value, pathSegments);
       if (value !== void 0) return true;
-      if (authoredPaths.has(paths.canonicalizePath(pathSegments).key)) return true;
+      if (authoredPaths.has(devtoolsShared.canonicalizePath(pathSegments).key)) return true;
       return !schema.isPreprocessOrCoerceLeaf(pathSegments);
     });
   }
@@ -4147,7 +4238,7 @@ function createFormStore(options) {
   const blankPaths = vue.reactive(/* @__PURE__ */ new Set());
   const originalBlankPaths = /* @__PURE__ */ new Set();
   for (const raw of initialTransientList) {
-    const key = paths.coerceToPathKey(raw);
+    const key = devtoolsShared.coerceToPathKey(raw);
     blankPaths.add(key);
     originalBlankPaths.add(key);
   }
@@ -4167,7 +4258,7 @@ function createFormStore(options) {
     const result = /* @__PURE__ */ new Map();
     if (blankPaths.size === 0) return result;
     for (const pathKey of blankPaths) {
-      const segments = paths.segmentsForPathKey(pathKey);
+      const segments = devtoolsShared.segmentsForPathKey(pathKey);
       if (segments === null) continue;
       if (!schema.isRequiredAtPath(segments)) continue;
       result.set(pathKey, [makeBlankRequiredError(segments, formKey)]);
@@ -4199,7 +4290,7 @@ function createFormStore(options) {
   });
   const pathAsyncCache = /* @__PURE__ */ new Map();
   function pathHasAsyncValidation(path) {
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     return pathHasAsyncValidationByKey(key, path);
   }
   function pathHasAsyncValidationByKey(key, segments) {
@@ -4303,9 +4394,9 @@ function createFormStore(options) {
   }
   function cancelTransformsUnder(prefix) {
     for (const [key, run] of [...transformRuns]) {
-      const segs = paths.segmentsForPathKey(key);
+      const segs = devtoolsShared.segmentsForPathKey(key);
       if (segs === null) continue;
-      if (!paths.isPathPrefix(prefix, segs)) continue;
+      if (!devtoolsShared.isPathPrefix(prefix, segs)) continue;
       releaseTransformRun(key, run);
       transformRuns.delete(key);
       transformErrors.delete(key);
@@ -4319,7 +4410,7 @@ function createFormStore(options) {
         transformWaiters.push({ key: null, resolve });
       });
     }
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     if ((fieldTransformCounts.get(key) ?? 0) === 0) return Promise.resolve();
     return new Promise((resolve) => {
       transformWaiters.push({ key, resolve });
@@ -4328,7 +4419,7 @@ function createFormStore(options) {
   const initStamp = (/* @__PURE__ */ new Date()).toISOString();
   diffAndApply({}, schemaInitialData, [], (patch) => {
     if (patch.kind !== "added") return;
-    const { key } = paths.canonicalizePath(patch.path);
+    const { key } = devtoolsShared.canonicalizePath(patch.path);
     originals.set(key, { segments: patch.path, value: patch.newValue });
     ensurePathOrdinal(key);
   });
@@ -4357,7 +4448,7 @@ function createFormStore(options) {
   } else {
     diffAndApply({}, initialData, [], (patch) => {
       if (patch.kind !== "added") return;
-      const { key } = paths.canonicalizePath(patch.path);
+      const { key } = devtoolsShared.canonicalizePath(patch.path);
       fields.set(key, {
         path: patch.path,
         updatedAt: initStamp,
@@ -4423,7 +4514,7 @@ function createFormStore(options) {
   function commitWritePatches(patches, meta) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     for (const patch of patches) {
-      const { key } = paths.canonicalizePath(patch.path);
+      const { key } = devtoolsShared.canonicalizePath(patch.path);
       if (patch.kind === "added" && !originals.has(key)) {
         originals.set(key, { segments: patch.path, value: void 0 });
       }
@@ -4585,7 +4676,7 @@ function createFormStore(options) {
       }
     }
     const currentValue = getAtPath(form.value, path);
-    const pathKey = paths.canonicalizePath(path).key;
+    const pathKey = devtoolsShared.canonicalizePath(path).key;
     if (meta?.blank === true) {
       blankPaths.add(pathKey);
     } else {
@@ -4645,7 +4736,7 @@ function createFormStore(options) {
       arrayIdentity.realign(path);
     } else if (isContainer(currentValue) && !isContainer(value)) {
       if (subtreeHadRealBaseline(path, currentValue)) {
-        removedSubtrees.add(paths.canonicalizePath(path).key);
+        removedSubtrees.add(devtoolsShared.canonicalizePath(path).key);
       }
     }
     const effectiveModeAfterWrite = meta?.instance?.validateOn ?? fieldValidationMode;
@@ -4659,7 +4750,7 @@ function createFormStore(options) {
   }
   function reshapeUnionVariant(parentPath, oldDiscValue, newDiscValue, variantDefault, consumerOverrides, meta) {
     const sameDisc = Object.is(oldDiscValue, newDiscValue);
-    const parentKey = paths.canonicalizePath(parentPath).key;
+    const parentKey = devtoolsShared.canonicalizePath(parentPath).key;
     let baseline = variantDefault;
     let restoredBlanks;
     const effectiveRemember = meta?.instance?.rememberVariants ?? rememberVariants;
@@ -4714,7 +4805,7 @@ function createFormStore(options) {
           path: [...parentPath, ...err.path]
         }));
         applySchemaErrorsForSubtree(parentPath, reStamped);
-        const { key: parentKey2 } = paths.canonicalizePath(parentPath);
+        const { key: parentKey2 } = devtoolsShared.canonicalizePath(parentPath);
         const prevValidation = fieldValidationState.get(parentKey2);
         if (prevValidation !== void 0) {
           if (prevValidation.timer !== null) clearTimeout(prevValidation.timer);
@@ -4738,7 +4829,7 @@ function createFormStore(options) {
     const effectiveMode = override?.mode ?? fieldValidationMode;
     if (effectiveMode === "submit") return;
     const effectiveDebounce = override?.debounceMs ?? fieldValidationDebounceMs;
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     const prev = fieldValidationState.get(key);
     if (prev !== void 0) {
       if (prev.timer !== null) clearTimeout(prev.timer);
@@ -4769,7 +4860,7 @@ function createFormStore(options) {
       const subtreeScope = path.length > 0 && schema.hasContainerOrRootRefine?.() === false;
       const scopePath = subtreeScope ? path : void 0;
       const dataAtScope = subtreeScope ? getAtPath(form.value, path) : form.value;
-      const scopeKey = subtreeScope ? paths.canonicalizePath(path).key : paths.ROOT_PATH_KEY;
+      const scopeKey = subtreeScope ? devtoolsShared.canonicalizePath(path).key : devtoolsShared.ROOT_PATH_KEY;
       void Promise.resolve().then(() => schema.validateAtPath(dataAtScope, scopePath)).then((response) => {
         if (fresh.aborted) return;
         if (myEpoch <= lastCommittedEpoch) return;
@@ -4814,9 +4905,9 @@ function createFormStore(options) {
   }
   function cancelFieldValidationUnder(prefix) {
     for (const [key, entry] of [...fieldValidationState]) {
-      const segs = paths.segmentsForPathKey(key);
+      const segs = devtoolsShared.segmentsForPathKey(key);
       if (segs === null) continue;
-      if (!paths.isPathPrefix(prefix, segs)) continue;
+      if (!devtoolsShared.isPathPrefix(prefix, segs)) continue;
       if (entry.timer !== null) {
         clearTimeout(entry.timer);
       } else if (!entry.settled && !entry.released) {
@@ -4889,7 +4980,7 @@ function createFormStore(options) {
   }
   function appendErrorsTo(map, entries) {
     for (const raw of entries) {
-      const { key } = paths.canonicalizePath(raw.path);
+      const { key } = devtoolsShared.canonicalizePath(raw.path);
       const current = map.get(key);
       if (current === void 0) {
         map.set(key, [raw]);
@@ -4907,11 +4998,11 @@ function createFormStore(options) {
       map.clear();
       return;
     }
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     map.delete(key);
   }
   function setSchemaErrorsForPath(path, entries) {
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     if (entries.length === 0) {
       schemaErrors.delete(key);
       return;
@@ -4919,10 +5010,10 @@ function createFormStore(options) {
     schemaErrors.set(key, [...entries]);
   }
   function applySchemaErrorsForSubtree(path, entries) {
-    const parentKey = paths.canonicalizePath(path).key;
+    const parentKey = devtoolsShared.canonicalizePath(path).key;
     const grouped = /* @__PURE__ */ new Map();
     for (const raw of entries) {
-      const { key } = paths.canonicalizePath(raw.path);
+      const { key } = devtoolsShared.canonicalizePath(raw.path);
       const list = grouped.get(key);
       if (list === void 0) grouped.set(key, [raw]);
       else list.push(raw);
@@ -4948,7 +5039,7 @@ function createFormStore(options) {
     replaceErrorsIn(userErrors, entries);
   }
   function setUserErrorsForPath(path, entries) {
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     if (entries.length === 0) {
       userErrors.delete(key);
       return;
@@ -4959,7 +5050,7 @@ function createFormStore(options) {
     clearErrorsIn(userErrors, path);
   }
   function getErrorsForPath(path) {
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     const schemaForKey = schemaErrors.get(key);
     const userForKey = userErrors.get(key);
     const blankForKey = derivedBlankErrors.value.get(key);
@@ -4973,7 +5064,7 @@ function createFormStore(options) {
     return result;
   }
   function registerElement(path, element, formInstanceId) {
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     const record = elements.get(key);
     const raw = vue.markRaw(element);
     if (record === void 0) {
@@ -4993,7 +5084,7 @@ function createFormStore(options) {
     return true;
   }
   function deregisterElement(path, element) {
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     const record = elements.get(key);
     if (record === void 0) return 0;
     const removed = record.elements.delete(element);
@@ -5011,7 +5102,7 @@ function createFormStore(options) {
   }
   function markConnectedOptimistically(path) {
     if (!ssr) return;
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     const current = fields.get(key);
     if (current?.connected === true) return;
     touchFieldRecord(key, path, {
@@ -5021,7 +5112,7 @@ function createFormStore(options) {
     });
   }
   function markHostConnected(path, connected) {
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     const current = fields.get(key);
     if (connected) {
       if (current?.connected === true) return;
@@ -5036,7 +5127,7 @@ function createFormStore(options) {
     }
   }
   function markFocused(path, focused, meta) {
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     const current = fields.get(key);
     touchFieldRecord(key, path, {
       focused,
@@ -5056,7 +5147,7 @@ function createFormStore(options) {
       let snapshot = void 0;
       let snapshotScopeLength = 0;
       for (let i = path.length; i >= 0; i--) {
-        const ancestorKey = paths.canonicalizePath(path.slice(0, i)).key;
+        const ancestorKey = devtoolsShared.canonicalizePath(path.slice(0, i)).key;
         const entry = pathSnapshots.get(ancestorKey);
         if (entry !== void 0) {
           snapshot = entry;
@@ -5083,7 +5174,7 @@ function createFormStore(options) {
     }
   }
   function markInteracted(path) {
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     if (fields.get(key)?.interacted === true) return;
     touchFieldRecord(key, path, { interacted: true });
   }
@@ -5091,15 +5182,15 @@ function createFormStore(options) {
     const formValue = form.value;
     let touchedAny = false;
     for (const [, entry] of originals) {
-      if (!paths.isPathPrefix(segments, entry.segments)) continue;
+      if (!devtoolsShared.isPathPrefix(segments, entry.segments)) continue;
       if (!hasAtPath(formValue, entry.segments)) continue;
       touchedAny = true;
-      const leafKey = paths.canonicalizePath(entry.segments).key;
+      const leafKey = devtoolsShared.canonicalizePath(entry.segments).key;
       const current = fields.get(leafKey);
       if (current?.touched === true) continue;
       touchFieldRecord(leafKey, entry.segments, { touched: true });
     }
-    if (!touchedAny && paths.__DEV__) {
+    if (!touchedAny && devtoolsShared.__DEV__) {
       console.warn(
         `[attaform] form.touch(): no fields resolved at path ${JSON.stringify(segments)}. Check the path matches an existing field or container.`
       );
@@ -5162,25 +5253,25 @@ function createFormStore(options) {
     }
   }
   function clearHydrationFailedEntry() {
-    const existing = schemaErrors.get(paths.ROOT_PATH_KEY);
+    const existing = schemaErrors.get(devtoolsShared.ROOT_PATH_KEY);
     if (existing === void 0) return;
     const filtered = existing.filter((e) => e.code !== AttaformErrorCode.HydrationFailed);
     if (filtered.length === 0) {
-      schemaErrors.delete(paths.ROOT_PATH_KEY);
+      schemaErrors.delete(devtoolsShared.ROOT_PATH_KEY);
     } else {
-      schemaErrors.set(paths.ROOT_PATH_KEY, filtered);
+      schemaErrors.set(devtoolsShared.ROOT_PATH_KEY, filtered);
     }
   }
   function appendHydrationFailedEntry(error) {
     const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Hydration failed";
     const entry = {
       message,
-      path: [...paths.ROOT_PATH],
+      path: [...devtoolsShared.ROOT_PATH],
       formKey,
       code: AttaformErrorCode.HydrationFailed
     };
-    const existing = schemaErrors.get(paths.ROOT_PATH_KEY) ?? [];
-    schemaErrors.set(paths.ROOT_PATH_KEY, [...existing, entry]);
+    const existing = schemaErrors.get(devtoolsShared.ROOT_PATH_KEY) ?? [];
+    schemaErrors.set(devtoolsShared.ROOT_PATH_KEY, [...existing, entry]);
     return entry;
   }
   function reset(nextDefaultValues) {
@@ -5199,7 +5290,7 @@ function createFormStore(options) {
     originals.clear();
     diffAndApply({}, next, [], (patch) => {
       if (patch.kind !== "added") return;
-      const { key } = paths.canonicalizePath(patch.path);
+      const { key } = devtoolsShared.canonicalizePath(patch.path);
       originals.set(key, { segments: patch.path, value: patch.newValue });
     });
     if (nextDefaultValues !== void 0) {
@@ -5259,14 +5350,14 @@ function createFormStore(options) {
     }
   }
   function resetField(path) {
-    const { key: targetKey, segments: targetSegments } = paths.canonicalizePath(path);
+    const { key: targetKey, segments: targetSegments } = devtoolsShared.canonicalizePath(path);
     variantMemory.clearUnderPath(targetSegments);
     cancelFieldValidationUnder(targetSegments);
     cancelTransformsUnder(targetSegments);
     for (const [snapKey] of [...pathSnapshots]) {
-      const segs = paths.segmentsForPathKey(snapKey);
+      const segs = devtoolsShared.segmentsForPathKey(snapKey);
       if (segs === null) continue;
-      if (paths.isPathPrefix(targetSegments, segs)) pathSnapshots.delete(snapKey);
+      if (devtoolsShared.isPathPrefix(targetSegments, segs)) pathSnapshots.delete(snapKey);
     }
     const leafEntry = originals.get(targetKey);
     if (leafEntry !== void 0) {
@@ -5281,7 +5372,7 @@ function createFormStore(options) {
       let anyMatch = false;
       for (const [, entry] of originals) {
         const leafSegments = entry.segments;
-        if (!paths.isPathPrefix(targetSegments, leafSegments)) continue;
+        if (!devtoolsShared.isPathPrefix(targetSegments, leafSegments)) continue;
         if (leafSegments.length === targetSegments.length) continue;
         anyMatch = true;
         const relative = leafSegments.slice(targetSegments.length);
@@ -5302,14 +5393,14 @@ function createFormStore(options) {
     deleteErrorsUnderPrefix(schemaErrors, targetSegments);
     deleteErrorsUnderPrefix(userErrors, targetSegments);
     for (const [fieldKey, record] of Array.from(fields.entries())) {
-      if (paths.isPathPrefix(targetSegments, record.path)) clearFieldRecordFlags(fieldKey);
+      if (devtoolsShared.isPathPrefix(targetSegments, record.path)) clearFieldRecordFlags(fieldKey);
     }
   }
   function deleteErrorsUnderPrefix(map, prefix) {
     for (const [errorKey, errs] of Array.from(map.entries())) {
       const first = errs[0];
       if (first === void 0) continue;
-      if (paths.isPathPrefix(prefix, first.path)) {
+      if (devtoolsShared.isPathPrefix(prefix, first.path)) {
         map.delete(errorKey);
       }
     }
@@ -5320,7 +5411,7 @@ function createFormStore(options) {
     fields.set(pathKey, withClearedHistoryFlags(record, (/* @__PURE__ */ new Date()).toISOString()));
   }
   function isPristineAtPath(path) {
-    const { key, segments } = paths.canonicalizePath(path);
+    const { key, segments } = devtoolsShared.canonicalizePath(path);
     return isPristineAtPathByKey(key, segments);
   }
   function isPristineAtPathByKey(key, segments) {
@@ -5336,7 +5427,7 @@ function createFormStore(options) {
     let had = false;
     diffAndApply(removedValue, void 0, prefix, (patch) => {
       if (had || patch.kind !== "removed") return;
-      const record = originals.get(paths.canonicalizePath(patch.path).key);
+      const record = originals.get(devtoolsShared.canonicalizePath(patch.path).key);
       if (record?.value !== void 0) had = true;
     });
     return had;
@@ -5344,20 +5435,20 @@ function createFormStore(options) {
   function hasRemovedSubtreeUnder(prefix) {
     if (removedSubtrees.size === 0) return false;
     for (const key of removedSubtrees) {
-      const segments = paths.segmentsForPathKey(key);
+      const segments = devtoolsShared.segmentsForPathKey(key);
       if (segments === null) continue;
-      if (!paths.isPathPrefix(prefix, segments)) continue;
+      if (!devtoolsShared.isPathPrefix(prefix, segments)) continue;
       if (isContainer(getAtPath(vue.toRaw(form.value), segments))) continue;
       return true;
     }
     return false;
   }
   function getFieldRecord(path) {
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     return fields.get(key);
   }
   function getOriginalAtPath(path) {
-    const { key } = paths.canonicalizePath(path);
+    const { key } = devtoolsShared.canonicalizePath(path);
     return originals.get(key)?.value;
   }
   function getFirstErrorElement(formInstanceId) {
@@ -5473,33 +5564,6 @@ function createFormStore(options) {
   };
 }
 
-function captureUserCallSite() {
-  const raw = new Error().stack;
-  if (typeof raw !== "string") return void 0;
-  const lines = raw.split("\n");
-  for (let i = 1; i < lines.length; i++) {
-    const frame = lines[i];
-    if (frame === void 0) continue;
-    if (/attaform[/-]forms?/i.test(frame)) continue;
-    if (/\bforms\.[A-Za-z0-9_-]+\.m?js\b/.test(frame)) continue;
-    const trimmed = frame.trim();
-    if (trimmed.length === 0) continue;
-    return shortenSourceFrame(trimmed);
-  }
-  return void 0;
-}
-function shortenSourceFrame(frame) {
-  const match = /(?:^|\s|\()([^\s()]+):(\d+):\d+\)?$/.exec(frame);
-  if (match === null) return frame;
-  const [, urlOrPath, line] = match;
-  if (urlOrPath === void 0 || line === void 0) return frame;
-  let path = urlOrPath;
-  path = path.replace(/^[a-z]+:\/\/[^/]+\//i, "");
-  path = path.replace(/^_nuxt\//, "");
-  path = path.replace(/^\//, "");
-  return `(${path}:${line})`;
-}
-
 function getComputedSchema(formKey, schemaOrCallback, options) {
   if (typeof schemaOrCallback === "function") return schemaOrCallback(formKey, options);
   return schemaOrCallback;
@@ -5540,7 +5604,7 @@ function errorFieldsEqual(av, bvi) {
   if (av.message !== bvi.message) return false;
   if (av.code !== bvi.code) return false;
   if (av.formKey !== bvi.formKey) return false;
-  if (av.path !== bvi.path && !paths.pathsEqual(av.path, bvi.path)) return false;
+  if (av.path !== bvi.path && !devtoolsShared.pathsEqual(av.path, bvi.path)) return false;
   return dataEqual(av.data, bvi.data);
 }
 function errorsEqual(a, b) {
@@ -5715,12 +5779,12 @@ function resolveTrichotomy(input) {
 
 function useAbstractForm(configuration, options) {
   if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
-    throw new paths.InvalidUseFormConfigError();
+    throw new devtoolsShared.InvalidUseFormConfigError();
   }
   const key = resolveFormKey(configuration.key);
   const instance = vue.getCurrentInstance();
-  if (instance !== null) paths.ensureAttaformInstalled(instance.appContext.app);
-  const registry = options?.registry ?? paths.useRegistry();
+  if (instance !== null) devtoolsShared.ensureAttaformInstalled(instance.appContext.app);
+  const registry = options?.registry ?? devtoolsShared.useRegistry();
   const resolvedDefaults = resolveTrichotomy(configuration.defaultValues);
   const materialisedDefaults = resolvedDefaults.kind === "sync" ? resolvedDefaults.value : void 0;
   const { defaultValues: _droppedDefaults, ...configWithoutDefaults } = configuration;
@@ -5735,7 +5799,7 @@ function useAbstractForm(configuration, options) {
   });
   const resolvedSchema = getComputedSchema(key, configuration.schema, { maxRecursionDepth });
   const existing = registry.forms.get(key);
-  if (paths.__DEV__ && existing !== void 0) {
+  if (devtoolsShared.__DEV__ && existing !== void 0) {
     void import('../chunks/dev-key-collision-warnings.cjs').then((m) => {
       void m.warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
     });
@@ -5772,11 +5836,11 @@ function useAbstractForm(configuration, options) {
   }
   if (configuration.key === void 0) {
     recordAmbientProvide(registry.ssr);
-    vue.provide(paths.kFormContext, state);
+    vue.provide(devtoolsShared.kFormContext, state);
   }
   const formInstanceId = vue.getCurrentInstance() !== null ? vue.useId() : `atta:form-instance:${formInstanceCounter++}`;
   if (vue.getCurrentInstance() !== null) {
-    vue.provide(paths.kFormInstanceId, formInstanceId);
+    vue.provide(devtoolsShared.kFormInstanceId, formInstanceId);
   }
   const apiOptions = {};
   if (merged.onInvalidSubmit !== void 0) {
@@ -5883,9 +5947,9 @@ function buildFreshState(key, schema, configuration, registry) {
 }
 let anonCounter = 0;
 let formInstanceCounter = 0;
-const ambientProvideHistory = paths.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+const ambientProvideHistory = devtoolsShared.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
 function recordAmbientProvide(ssr) {
-  if (!paths.__DEV__ || ssr || ambientProvideHistory === null) return;
+  if (!devtoolsShared.__DEV__ || ssr || ambientProvideHistory === null) return;
   const instance = vue.getCurrentInstance();
   if (instance === null) return;
   const instanceKey = instance;
@@ -5902,7 +5966,7 @@ function recordAmbientProvide(ssr) {
 function resolveFormKey(key) {
   if (key !== void 0 && key !== null && key !== "") {
     if (key.startsWith(RESERVED_KEY_PREFIX)) {
-      throw new paths.ReservedFormKeyError(key);
+      throw new devtoolsShared.ReservedFormKeyError(key);
     }
     return key;
   }
@@ -5917,8 +5981,8 @@ function injectForm(input) {
   const key = typeof input === "string" ? input : input?.key;
   const ssrAccessed = typeof input === "object" && input !== null ? input.__ssrAccessed === true : false;
   const instance = vue.getCurrentInstance();
-  if (instance !== null) paths.ensureAttaformInstalled(instance.appContext.app);
-  const registry = paths.useRegistry();
+  if (instance !== null) devtoolsShared.ensureAttaformInstalled(instance.appContext.app);
+  const registry = devtoolsShared.useRegistry();
   const state = resolveState(key, registry);
   if (state === null) return null;
   if (vue.getCurrentScope() !== void 0) {
@@ -5934,7 +5998,7 @@ function injectForm(input) {
   if (history !== void 0) {
     apiOptions.history = history;
   }
-  const ambientInstanceId = vue.getCurrentInstance() !== null ? vue.inject(paths.kFormInstanceId, null) : null;
+  const ambientInstanceId = vue.getCurrentInstance() !== null ? vue.inject(devtoolsShared.kFormInstanceId, null) : null;
   const formInstanceId = ambientInstanceId ?? (vue.getCurrentInstance() !== null ? vue.useId() : `atta:form-instance-injected:${injectedInstanceCounter++}`);
   return buildFormApi(
     state,
@@ -5951,7 +6015,7 @@ function resolveState(key, registry) {
     }
     return stored;
   }
-  const ambient = vue.inject(paths.kFormContext, null);
+  const ambient = vue.inject(devtoolsShared.kFormContext, null);
   if (ambient === null) return null;
   warnIfAmbientProviderHadDuplicates();
   return ambient;
@@ -5962,7 +6026,7 @@ function availableKeysHint$1(forms) {
   return `Registered keys: ${addressable.map((key) => `'${key}'`).join(", ")}.`;
 }
 function warnMiss$1(detail, ssr, forms) {
-  if (!paths.__DEV__ || ssr) return;
+  if (!devtoolsShared.__DEV__ || ssr) return;
   const frame = captureUserCallSite();
   const parts = [`[attaform] injectForm: ${detail}. Returning null.`];
   const keys = availableKeysHint$1(forms);
@@ -5974,7 +6038,7 @@ function warnMiss$1(detail, ssr, forms) {
   console.warn(parts.join(" "));
 }
 function warnIfAmbientProviderHadDuplicates() {
-  if (!paths.__DEV__ || ambientProvideHistory === null) return;
+  if (!devtoolsShared.__DEV__ || ambientProvideHistory === null) return;
   let ancestor = vue.getCurrentInstance()?.parent ?? null;
   while (ancestor !== null) {
     const history = ambientProvideHistory.get(ancestor);
@@ -5991,7 +6055,7 @@ function warnIfAmbientProviderHadDuplicates() {
   }
 }
 
-const warnedNoParentRV = paths.__DEV__ ? /* @__PURE__ */ new WeakSet() : null;
+const warnedNoParentRV = devtoolsShared.__DEV__ ? /* @__PURE__ */ new WeakSet() : null;
 let warnedOutsideSetup = false;
 function makeRegisterValueProxy(capturedRegisterValue) {
   return new Proxy({}, {
@@ -6030,7 +6094,7 @@ function useRegister() {
     warnOutsideSetup();
     return makeRegisterValueProxy(vue.shallowRef(void 0));
   }
-  paths.ensureAttaformInstalled(instance.appContext.app);
+  devtoolsShared.ensureAttaformInstalled(instance.appContext.app);
   const capturedRegisterValue = vue.shallowRef(void 0);
   const refreshAndStripBridgeAttrs = () => {
     const rawAttrs = instance.attrs;
@@ -6068,7 +6132,7 @@ function useRegister() {
   return makeRegisterValueProxy(capturedRegisterValue);
 }
 function warnOutsideSetup() {
-  if (!paths.__DEV__) return;
+  if (!devtoolsShared.__DEV__) return;
   if (warnedOutsideSetup) return;
   warnedOutsideSetup = true;
   const frame = captureUserCallSite();
@@ -6077,7 +6141,7 @@ function warnOutsideSetup() {
   );
 }
 function warnNoParentRV(instance) {
-  if (!paths.__DEV__ || warnedNoParentRV === null) return;
+  if (!devtoolsShared.__DEV__ || warnedNoParentRV === null) return;
   if (warnedNoParentRV.has(instance)) return;
   warnedNoParentRV.add(instance);
   const frame = captureUserCallSite();
@@ -6086,7 +6150,7 @@ function warnNoParentRV(instance) {
   );
 }
 
-const LAZY_BRAND = Symbol.for("attaform/wizard-lazy");
+const LAZY_BRAND = /* @__PURE__ */ Symbol.for("attaform/wizard-lazy");
 function lazy(resolve) {
   return { [LAZY_BRAND]: true, resolve };
 }
@@ -6236,12 +6300,12 @@ function asHandleSubmitSource(form) {
 }
 function useWizard(options) {
   const rawSteps = Array.isArray(options.steps) ? options.steps : [];
-  if (rawSteps.length === 0 && paths.__DEV__) {
+  if (rawSteps.length === 0 && devtoolsShared.__DEV__) {
     console.error(
       "[attaform] useWizard({ steps }): expected a non-empty array of step slots. Continuing with an empty step list \u2014 wizard.currentStep reads as undefined, navigation refuses, handleSubmit no-ops."
     );
   }
-  const registry = paths.useRegistry();
+  const registry = devtoolsShared.useRegistry();
   const noopForms = /* @__PURE__ */ new Map();
   const lazyNoopScope = vue.effectScope(true);
   for (const slot of rawSteps) {
@@ -6372,7 +6436,7 @@ function useWizard(options) {
       const form = resolveSlot(slot, i, slotCtx);
       if (form === void 0) continue;
       if (seen.has(form.key)) {
-        if (paths.__DEV__) {
+        if (devtoolsShared.__DEV__) {
           console.warn(
             `[attaform] useWizard: step "${form.key}" appears in more than one slot. The wizard treats the first occurrence as canonical and drops later duplicates.`
           );
@@ -6631,7 +6695,7 @@ function useWizard(options) {
     }
   });
   const statuses = buildWizardStatusesProxy(statusesRecord);
-  if (paths.__DEV__ && seedRef.value !== void 0) {
+  if (devtoolsShared.__DEV__ && seedRef.value !== void 0) {
     const seedMap = seedRef.value;
     const known = new Set(compiledSteps.value.map((s) => s.key));
     const unknown = [];
@@ -6670,7 +6734,7 @@ function useWizard(options) {
   const visited = vue.ref([]);
   const wantsDefaultUrlSync = options.restore !== false || options.persist !== false;
   const historyHandle = wantsDefaultUrlSync ? createWizardHistory(DEFAULT_STEP_PARAM) : NOOP_WIZARD_HISTORY;
-  const injectedResolver = vue.inject(paths.kAttaformWizardActiveStepResolver, null);
+  const injectedResolver = vue.inject(devtoolsShared.kAttaformWizardActiveStepResolver, null);
   const urlMirror = vue.ref(void 0);
   const initialUrlValue = injectedResolver !== null ? injectedResolver(DEFAULT_STEP_PARAM) : historyHandle.read();
   urlMirror.value = initialUrlValue;
@@ -6703,7 +6767,7 @@ function useWizard(options) {
   if (restoredStep !== void 0 && isCompiledKey(restoredStep)) {
     initialKey = restoredStep;
   } else {
-    if (paths.__DEV__ && restoredStep !== void 0 && restoredStep !== "" && !isCompiledKey(restoredStep)) {
+    if (devtoolsShared.__DEV__ && restoredStep !== void 0 && restoredStep !== "" && !isCompiledKey(restoredStep)) {
       console.warn(
         `[attaform] useWizard: restore() yielded step "${restoredStep}" which is not in the compiled step list. Falling back to the first step.`
       );
@@ -6736,7 +6800,7 @@ function useWizard(options) {
       (step) => {
         if (step === void 0) return;
         if (!isCompiledKey(step)) {
-          if (paths.__DEV__) {
+          if (devtoolsShared.__DEV__) {
             console.warn(
               `[attaform] useWizard: restore() yielded step "${step}" which is not in the compiled step list. Ignoring.`
             );
@@ -6793,7 +6857,7 @@ function useWizard(options) {
   }
   async function next() {
     if (submitting.value) {
-      if (paths.__DEV__) {
+      if (devtoolsShared.__DEV__) {
         console.warn(
           `[attaform] wizard.next(): blocked while a submit is in flight. Wait for handleSubmit to settle.`
         );
@@ -6802,14 +6866,14 @@ function useWizard(options) {
     }
     const list = compiledSteps.value;
     if (list.length === 0) {
-      if (paths.__DEV__) {
+      if (devtoolsShared.__DEV__) {
         console.warn(`[attaform] wizard.next(): wizard has no compiled steps; no-op.`);
       }
       return;
     }
     const idx = activeIndex.value;
     if (idx < 0 || idx >= list.length - 1) {
-      if (paths.__DEV__) {
+      if (devtoolsShared.__DEV__) {
         console.warn(
           `[attaform] wizard.next(): already on the final step ("${activeKey.value}"). Use wizard.handleSubmit() to submit.`
         );
@@ -6822,21 +6886,21 @@ function useWizard(options) {
   }
   async function tryNext() {
     if (submitting.value) {
-      if (paths.__DEV__) {
+      if (devtoolsShared.__DEV__) {
         console.warn(`[attaform] wizard.tryNext(): blocked while a submit is in flight.`);
       }
       return false;
     }
     const list = compiledSteps.value;
     if (list.length === 0) {
-      if (paths.__DEV__) {
+      if (devtoolsShared.__DEV__) {
         console.warn(`[attaform] wizard.tryNext(): wizard has no compiled steps; no-op.`);
       }
       return false;
     }
     const idx = activeIndex.value;
     if (idx < 0 || idx >= list.length - 1) {
-      if (paths.__DEV__) {
+      if (devtoolsShared.__DEV__) {
         console.warn(
           `[attaform] wizard.tryNext(): already on the final step ("${activeKey.value}"). Use wizard.handleSubmit() to submit.`
         );
@@ -6855,20 +6919,20 @@ function useWizard(options) {
   }
   function back() {
     if (submitting.value) {
-      if (paths.__DEV__) {
+      if (devtoolsShared.__DEV__) {
         console.warn(`[attaform] wizard.back(): blocked while a submit is in flight.`);
       }
       return;
     }
     if (compiledSteps.value.length === 0) {
-      if (paths.__DEV__) {
+      if (devtoolsShared.__DEV__) {
         console.warn(`[attaform] wizard.back(): wizard has no compiled steps; no-op.`);
       }
       return;
     }
     const idx = activeIndex.value;
     if (idx <= 0) {
-      if (paths.__DEV__) {
+      if (devtoolsShared.__DEV__) {
         console.warn(`[attaform] wizard.back(): already on the first step ("${activeKey.value}").`);
       }
       return;
@@ -6879,13 +6943,13 @@ function useWizard(options) {
   }
   function goTo(key) {
     if (submitting.value) {
-      if (paths.__DEV__) {
+      if (devtoolsShared.__DEV__) {
         console.warn(`[attaform] wizard.goTo(): blocked while a submit is in flight.`);
       }
       return;
     }
     if (!isCompiledKey(key)) {
-      if (paths.__DEV__) {
+      if (devtoolsShared.__DEV__) {
         const known = compiledSteps.value.map((s) => `"${s.key}"`).join(", ");
         console.warn(`[attaform] wizard.goTo("${key}"): unknown step key. Known keys: ${known}.`);
       }
@@ -6969,13 +7033,13 @@ function useWizard(options) {
         event.preventDefault();
       }
       if (compiledSteps.value.length === 0) {
-        if (paths.__DEV__) {
+        if (devtoolsShared.__DEV__) {
           console.warn(`[attaform] wizard.handleSubmit: wizard has no compiled steps; no-op.`);
         }
         return;
       }
       if (submitting.value) {
-        if (paths.__DEV__) {
+        if (devtoolsShared.__DEV__) {
           console.warn(
             `[attaform] wizard.handleSubmit: re-entrant submit while a prior call is still in flight; resolving no-op.`
           );
@@ -7025,7 +7089,7 @@ function useWizard(options) {
               try {
                 await onError(callbackErrors);
               } catch (cause) {
-                throw new paths.SubmitErrorHandlerError("User-provided onError threw", { cause });
+                throw new devtoolsShared.SubmitErrorHandlerError("User-provided onError threw", { cause });
               }
             }
             return;
@@ -7037,12 +7101,12 @@ function useWizard(options) {
             try {
               await onError(errors);
             } catch (cause) {
-              throw new paths.SubmitErrorHandlerError("User-provided onError threw", { cause });
+              throw new devtoolsShared.SubmitErrorHandlerError("User-provided onError threw", { cause });
             }
           }
         }
       } catch (err) {
-        submitError.value = paths.toError(err);
+        submitError.value = devtoolsShared.toError(err);
       } finally {
         submitting.value = false;
       }
@@ -7138,7 +7202,7 @@ function useWizard(options) {
   const existing = registry.wizards.get(wizardKey);
   if (existing === void 0) {
     registry.wizards.set(wizardKey, handle);
-  } else if (paths.__DEV__ && explicitKey !== void 0) {
+  } else if (devtoolsShared.__DEV__ && explicitKey !== void 0) {
     console.warn(
       `[attaform] useWizard({ key: "${wizardKey}" }): a wizard with this key is already registered. Keeping the existing handle. Pass a unique key to each useWizard call, or share the original handle via injectWizard("${wizardKey}").`
     );
@@ -7149,14 +7213,14 @@ function useWizard(options) {
   }
   if (vue.getCurrentInstance() !== null && explicitKey === void 0) {
     recordAmbientWizardProvide(registry.ssr);
-    vue.provide(paths.kAttaformAncestorWizard, handle);
+    vue.provide(devtoolsShared.kAttaformAncestorWizard, handle);
   }
   return handle;
 }
 let anonWizardCounter = 0;
-const ambientWizardProvideHistory = paths.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+const ambientWizardProvideHistory = devtoolsShared.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
 function recordAmbientWizardProvide(ssr) {
-  if (!paths.__DEV__ || ssr || ambientWizardProvideHistory === null) return;
+  if (!devtoolsShared.__DEV__ || ssr || ambientWizardProvideHistory === null) return;
   const instance = vue.getCurrentInstance();
   if (instance === null) return;
   const instanceKey = instance;
@@ -7186,8 +7250,8 @@ function isAnyForm(value) {
 function injectWizard(input) {
   const key = typeof input === "string" ? input : input?.key;
   const instance = vue.getCurrentInstance();
-  if (instance !== null) paths.ensureAttaformInstalled(instance.appContext.app);
-  const registry = paths.useRegistry();
+  if (instance !== null) devtoolsShared.ensureAttaformInstalled(instance.appContext.app);
+  const registry = devtoolsShared.useRegistry();
   if (key !== void 0) {
     const handle = registry.wizards.get(key);
     if (handle === void 0) {
@@ -7204,7 +7268,7 @@ function injectWizard(input) {
     }
     return handle;
   }
-  const ambient = vue.inject(paths.kAttaformAncestorWizard, null);
+  const ambient = vue.inject(devtoolsShared.kAttaformAncestorWizard, null);
   if (ambient === null) return null;
   warnIfAmbientWizardProviderHadDuplicates();
   return ambient;
@@ -7215,7 +7279,7 @@ function availableKeysHint(wizards) {
   return `Registered keys: ${keys}.`;
 }
 function warnMiss(detail, ssr, hint) {
-  if (!paths.__DEV__ || ssr) return;
+  if (!devtoolsShared.__DEV__ || ssr) return;
   const frame = captureUserCallSite();
   const parts = [`[attaform] injectWizard: ${detail}. Returning null.`];
   if (hint !== void 0) parts.push(hint);
@@ -7226,7 +7290,7 @@ function warnMiss(detail, ssr, hint) {
   console.warn(parts.join(" "));
 }
 function warnIfAmbientWizardProviderHadDuplicates() {
-  if (!paths.__DEV__ || ambientWizardProvideHistory === null) return;
+  if (!devtoolsShared.__DEV__ || ambientWizardProvideHistory === null) return;
   let ancestor = vue.getCurrentInstance()?.parent ?? null;
   while (ancestor !== null) {
     const history = ambientWizardProvideHistory.get(ancestor);
@@ -7243,11 +7307,31 @@ function warnIfAmbientWizardProviderHadDuplicates() {
   }
 }
 
+function escapeForInlineScript(json) {
+  return json.replace(/[<>&\u2028\u2029]/g, (char) => {
+    switch (char) {
+      case "<":
+        return "\\u003c";
+      case ">":
+        return "\\u003e";
+      case "&":
+        return "\\u0026";
+      case "\u2028":
+        return "\\u2028";
+      case "\u2029":
+        return "\\u2029";
+      default:
+        return char;
+    }
+  });
+}
+
 exports.AttaformErrorCode = AttaformErrorCode;
 exports.DEFAULT_TIMINGS = DEFAULT_TIMINGS;
 exports.defaultCoercionRules = defaultCoercionRules;
 exports.defaultDisplayState = defaultDisplayState;
 exports.defineCoercion = defineCoercion;
+exports.escapeForInlineScript = escapeForInlineScript;
 exports.getAtPath = getAtPath;
 exports.humanize = humanize;
 exports.injectForm = injectForm;
@@ -7264,4 +7348,4 @@ exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
 exports.useRegister = useRegister;
 exports.useWizard = useWizard;
-//# sourceMappingURL=attaform.BkUzunyB.cjs.map
+//# sourceMappingURL=attaform.DQT7_-FO.cjs.map