attaform 0.27.5 → 0.28.0

package/dist/{shared/attaform.f2zyNh5d.cjs → dev/shared/attaform-dev.6qxD-Yqo.mjs}

@@ -1,7 +1,6 @@
-'use strict';
-
-const serializeScript = require('./attaform.Cg1rUfcF.cjs');
-const devtoolsShared = require('./attaform.Biytrv0-.cjs');
+import { A as AttaformErrorCode, n as isPlainRecord, s as slimKindOf } from './attaform-dev.WmuhD_CZ.mjs';
+import { e as canonicalizePath } from './attaform-dev.Dr2YzS5B.mjs';
+import { a as safeOwnRead, b as safeAssign } from './attaform-dev.By4PRjt0.mjs';
 
 const PATH_SEPARATOR = ".";
 function createAbstractSchema(rootSchema, intro, services, formKey, options) {
@@ -11,6 +10,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
   const discriminatorCache = /* @__PURE__ */ new Map();
   let asyncValidationFlag = null;
   let containerRefineFlag = null;
+  let discriminatedUnionFlag = null;
   function computeDiscriminator(path) {
     const candidates = path.length === 0 ? [rootSchema] : services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
     let matchedUnion;
@@ -62,6 +62,10 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       containerRefineFlag ?? (containerRefineFlag = intro.hasContainerOrRootRefine(rootSchema));
       return containerRefineFlag;
     },
+    hasDiscriminatedUnions() {
+      discriminatedUnionFlag ?? (discriminatedUnionFlag = intro.containsDiscriminatedUnion(rootSchema));
+      return discriminatedUnionFlag;
+    },
     getDefaultValues(config) {
       return services.runStrictGetDefaults(rootSchema, config, formKey, maxRecursionDepth);
     },
@@ -83,14 +87,12 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       return services.deriveDefault(first, false, maxRecursionDepth, formKey);
     },
     arrayShapeAtPath(path) {
-      if (path.length === 0) return void 0;
+      if (path.length === 0) return null;
       const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
-      if (first === void 0) return void 0;
+      if (first === void 0) return null;
       const peeled = services.peelAllWrappers(first);
-      const kind = intro.kindOf(peeled);
-      if (kind === "tuple") return intro.getTupleItems(peeled).length;
-      if (kind === "array") return null;
-      return void 0;
+      if (intro.kindOf(peeled) === "tuple") return intro.getTupleItems(peeled).length;
+      return null;
     },
     isFixedObjectAtPath(path) {
       if (path.length === 0) {
@@ -118,7 +120,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       return out;
     },
     isLeafAtPath(path) {
-      const cacheKey = devtoolsShared.canonicalizePath(path).key;
+      const cacheKey = canonicalizePath(path).key;
       const cached = leafCache.get(cacheKey);
       if (cached !== void 0) return cached;
       const prim = this.getSlimPrimitiveTypesAtPath(path);
@@ -127,7 +129,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       return isLeaf;
     },
     isPreprocessOrCoerceLeaf(path) {
-      const cacheKey = devtoolsShared.canonicalizePath(path).key;
+      const cacheKey = canonicalizePath(path).key;
       const cached = preprocessOrCoerceCache.get(cacheKey);
       if (cached !== void 0) return cached;
       let hit = false;
@@ -154,7 +156,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       return services.resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth);
     },
     getUnionDiscriminatorAtPath(path) {
-      const cacheKey = devtoolsShared.canonicalizePath(path).key;
+      const cacheKey = canonicalizePath(path).key;
       if (discriminatorCache.has(cacheKey)) {
         return discriminatorCache.get(cacheKey);
       }
@@ -174,7 +176,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       function parseResultToResponse(result) {
         return result.success ? { data: result.data, errors: void 0, success: true, formKey } : {
           data: void 0,
-          errors: services.issuesToValidationErrors(result.issues, formKey),
+          errors: services.issuesToValidationErrors(result.issues),
           success: false,
           formKey
         };
@@ -227,8 +229,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
             {
               message,
               path: [...errPath],
-              formKey,
-              code: serializeScript.AttaformErrorCode.ValidatorThrew
+              code: AttaformErrorCode.ValidatorThrew
             }
           ],
           success: false,
@@ -242,8 +243,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
             {
               message: `Path '${p.join(PATH_SEPARATOR)}' did not resolve to any schema`,
               path: [...p],
-              formKey,
-              code: serializeScript.AttaformErrorCode.PathNotFound
+              code: AttaformErrorCode.PathNotFound
             }
           ],
           success: false,
@@ -257,16 +257,16 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
 
 function mergeDeep(base, override) {
   if (override === void 0) return base;
-  if (!serializeScript.isPlainRecord(override)) return override;
-  if (!serializeScript.isPlainRecord(base)) return override;
+  if (!isPlainRecord(override)) return override;
+  if (!isPlainRecord(base)) return override;
   const result = { ...base };
   for (const key of Object.keys(override)) {
-    const oVal = serializeScript.safeOwnRead(override, key);
-    const bVal = serializeScript.safeOwnRead(base, key);
-    if (serializeScript.isPlainRecord(oVal) && serializeScript.isPlainRecord(bVal)) {
-      serializeScript.safeAssign(result, key, mergeDeep(bVal, oVal));
+    const oVal = safeOwnRead(override, key);
+    const bVal = safeOwnRead(base, key);
+    if (isPlainRecord(oVal) && isPlainRecord(bVal)) {
+      safeAssign(result, key, mergeDeep(bVal, oVal));
     } else {
-      serializeScript.safeAssign(result, key, oVal);
+      safeAssign(result, key, oVal);
     }
   }
   return result;
@@ -359,6 +359,144 @@ function walkPathSegments(schema, segments, intro, maxDepth, lazyDepth) {
   }
 }
 
+function fixStructuralDefaults(schema, merged, useDefault, maxRecursionDepth, services) {
+  const ctx = {
+    useDefault,
+    maxDepth: maxRecursionDepth,
+    clean: true,
+    services
+  };
+  const data = fixNode(schema, merged, ctx, 0);
+  return { data, success: ctx.clean };
+}
+function fixNode(schema, value, ctx, lazyDepth) {
+  const { intro } = ctx.services;
+  if (intro.isCoercePrimitive(schema) || intro.isPreprocessNode(schema)) return value;
+  const kinds = ctx.services.slimPrimitivesOf(schema);
+  if (kinds.size > 0 && !kinds.has(slimKindOf(value))) {
+    const replacement = deriveFixValue(schema, value, ctx);
+    if (kinds.has(slimKindOf(replacement))) return replacement;
+    ctx.clean = false;
+    return replacement;
+  }
+  switch (intro.kindOf(schema)) {
+    case "optional":
+    case "nullable": {
+      if (value === void 0 || value === null) return value;
+      const inner = intro.unwrapInner(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth);
+    }
+    case "default":
+    case "readonly":
+    case "catch": {
+      const inner = intro.unwrapInner(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth);
+    }
+    case "branded": {
+      const inner = intro.unwrapBranded(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth);
+    }
+    case "effects": {
+      const inner = intro.unwrapEffectsSource(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth);
+    }
+    case "pipe":
+    case "pipeline": {
+      const pipeIn = intro.unwrapPipeIn(schema);
+      if (pipeIn === void 0 || intro.kindOf(pipeIn) === "transform") return value;
+      return fixNode(pipeIn, value, ctx, lazyDepth);
+    }
+    case "lazy": {
+      if (lazyDepth >= ctx.maxDepth) return value;
+      const inner = intro.unwrapLazy(schema);
+      return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth + 1);
+    }
+    case "discriminated-union": {
+      if (value === null || typeof value !== "object") return value;
+      const variant = selectVariantByValue(schema, value, intro);
+      if (variant === void 0) return value;
+      const record = value;
+      const shape = intro.getObjectShape(variant);
+      for (const key of Object.keys(record)) {
+        if (!(key in shape)) delete record[key];
+      }
+      for (const [key, sub] of Object.entries(shape)) {
+        record[key] = fixNode(sub, record[key], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "object": {
+      if (value === null || typeof value !== "object") return value;
+      const record = value;
+      for (const [key, sub] of Object.entries(intro.getObjectShape(schema))) {
+        record[key] = fixNode(sub, record[key], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "array": {
+      if (!Array.isArray(value)) return value;
+      const element = intro.getArrayElement(schema);
+      if (element === void 0) return value;
+      for (let i = 0; i < value.length; i++) {
+        value[i] = fixNode(element, value[i], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "tuple": {
+      if (!Array.isArray(value)) return value;
+      const items = intro.getTupleItems(schema);
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (item !== void 0) value[i] = fixNode(item, value[i], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "record": {
+      if (value === null || typeof value !== "object") return value;
+      const valueType = intro.getRecordValueType(schema);
+      if (valueType === void 0) return value;
+      const record = value;
+      for (const key of Object.keys(record)) {
+        record[key] = fixNode(valueType, record[key], ctx, lazyDepth);
+      }
+      return value;
+    }
+    case "intersection": {
+      const left = intro.getIntersectionLeft(schema);
+      const right = intro.getIntersectionRight(schema);
+      let out = value;
+      if (left !== void 0) out = fixNode(left, out, ctx, lazyDepth);
+      if (right !== void 0) out = fixNode(right, out, ctx, lazyDepth);
+      return out;
+    }
+    default:
+      return value;
+  }
+}
+function deriveFixValue(schema, value, ctx) {
+  const du = ctx.services.unwrapToDiscriminatedUnion(schema);
+  if (du !== void 0) {
+    const selected = selectVariantByValue(du, value, ctx.services.intro) ?? ctx.services.intro.getDiscriminatedOptions(du)[0];
+    if (selected !== void 0) {
+      return ctx.services.deriveDefault(selected, ctx.useDefault);
+    }
+  }
+  return ctx.services.deriveDefault(schema, ctx.useDefault);
+}
+function selectVariantByValue(du, value, intro) {
+  if (value === null || typeof value !== "object") return void 0;
+  const discKey = intro.getDiscriminator(du);
+  if (discKey === void 0) return void 0;
+  const discValue = value[discKey];
+  if (discValue === void 0) return void 0;
+  for (const opt of intro.getDiscriminatedOptions(du)) {
+    const litSchema = intro.getObjectShape(opt)[discKey];
+    if (litSchema === void 0 || intro.kindOf(litSchema) !== "literal") continue;
+    if (intro.getLiteralValues(litSchema).includes(discValue)) return opt;
+  }
+  return void 0;
+}
+
 const NO_EMBEDDED_DEFAULT = /* @__PURE__ */ Symbol("atta:no-embedded-default");
 function peelEmbeddedDefault(schema, intro) {
   let current = schema;
@@ -417,7 +555,7 @@ function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth =
       const shape = intro.getObjectShape(schema);
       const out = {};
       for (const [key, subSchema] of Object.entries(shape)) {
-        serializeScript.safeAssign(
+        safeAssign(
           out,
           key,
           deriveDefaultWalk(subSchema, useDefault, intro, maxDepth, ctx, lazyDepth)
@@ -541,9 +679,6 @@ function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth =
     }
     case "catch": {
       if (useDefault) return intro.getCatchDefault(schema);
-      if (ctx.catchOnUseDefaultFalse === "preserveCatch" && intro.hasCatchValue(schema)) {
-        return intro.getCatchDefault(schema);
-      }
       const inner = intro.unwrapInner(schema);
       return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
     }
@@ -595,6 +730,13 @@ function getFieldMetaForSchema(schema) {
 function getFieldMetaListForSchema(schema) {
   return lists.get(schema) ?? [];
 }
+let pathMapBuilder = null;
+function installFieldMetaPathMapBuilder(builder) {
+  pathMapBuilder = builder;
+}
+function buildFieldMetaPathMap(rootSchema, services) {
+  return pathMapBuilder === null ? void 0 : pathMapBuilder(rootSchema, services);
+}
 
 const PERMISSIVE_SLIM_KINDS = /* @__PURE__ */ new Set([
   "string",
@@ -667,7 +809,7 @@ function slimPrimitivesWalk(schema, intro, maxDepth, lazyDepth = 0) {
     case "literal": {
       const values = intro.getLiteralValues(schema);
       const out = /* @__PURE__ */ new Set();
-      for (const v of values) out.add(serializeScript.slimKindOf(v));
+      for (const v of values) out.add(slimKindOf(v));
       return out.size === 0 ? PERMISSIVE_SLIM_KINDS : out;
     }
     case "object":
@@ -754,6 +896,19 @@ function slimPrimitivesWalk(schema, intro, maxDepth, lazyDepth = 0) {
   }
 }
 
+const installingFieldMetaStore = {
+  add(schema, payload) {
+    installFieldMetaPathMapBuilder(getFieldMetaPathMap);
+    fieldMetaStore.add(schema, payload);
+    return installingFieldMetaStore;
+  },
+  get: (schema) => fieldMetaStore.get(schema),
+  has: (schema) => fieldMetaStore.has(schema),
+  remove: (schema) => {
+    fieldMetaStore.remove(schema);
+    return installingFieldMetaStore;
+  }
+};
 const pathMetaCache = /* @__PURE__ */ new WeakMap();
 function getFieldMetaPathMap(rootSchema, services) {
   const cached = pathMetaCache.get(rootSchema);
@@ -787,7 +942,7 @@ function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress,
   inProgress.add(schema);
   try {
     const { intro, peelAllWrappers, getFieldMetaList } = services;
-    const pathKey = devtoolsShared.canonicalizePath(path).key;
+    const pathKey = canonicalizePath(path).key;
     if (!map.has(pathKey)) {
       const payload = consumePayload(schema, counters, getFieldMetaList);
       if (payload !== void 0) {
@@ -905,15 +1060,4 @@ function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress,
   }
 }
 
-exports.NO_EMBEDDED_DEFAULT = NO_EMBEDDED_DEFAULT;
-exports.createAbstractSchema = createAbstractSchema;
-exports.deriveDefaultWalk = deriveDefaultWalk;
-exports.fieldMetaStore = fieldMetaStore;
-exports.getFieldMetaForSchema = getFieldMetaForSchema;
-exports.getFieldMetaListForSchema = getFieldMetaListForSchema;
-exports.getFieldMetaPathMap = getFieldMetaPathMap;
-exports.mergeDeep = mergeDeep;
-exports.peelEmbeddedDefault = peelEmbeddedDefault;
-exports.slimPrimitivesWalk = slimPrimitivesWalk;
-exports.walkPathSegments = walkPathSegments;
-//# sourceMappingURL=attaform.f2zyNh5d.cjs.map
+export { getFieldMetaListForSchema as a, buildFieldMetaPathMap as b, createAbstractSchema as c, deriveDefaultWalk as d, fixStructuralDefaults as f, getFieldMetaForSchema as g, installingFieldMetaStore as i, mergeDeep as m, slimPrimitivesWalk as s, walkPathSegments as w };

package/dist/{shared/attaform.CQN9R62B.cjs → dev/shared/attaform-dev.BJGA_UOS.mjs}

@@ -1,5 +1,3 @@
-'use strict';
-
 function canonicalStringify(value, seen = /* @__PURE__ */ new WeakSet()) {
   if (value === null) return "null";
   if (value === void 0) return "undefined";
@@ -35,5 +33,4 @@ function canonicalStringify(value, seen = /* @__PURE__ */ new WeakSet()) {
   return "unknown";
 }
 
-exports.canonicalStringify = canonicalStringify;
-//# sourceMappingURL=attaform.CQN9R62B.cjs.map
+export { canonicalStringify as c };

package/dist/{shared/attaform.Dc1mx48r.mjs → dev/shared/attaform-dev.BR8u0YOZ.mjs}

@@ -1,7 +1,7 @@
-import { a as InvalidUseFormConfigError } from './attaform.nMaz2C5P.mjs';
-import { u as useForm$2 } from './attaform.Cg_8gFQ7.mjs';
-import { u as useForm$1 } from './attaform.Dkjh_F30.mjs';
-import { f as fieldMetaStore, g as getFieldMetaForSchema } from './attaform.CTiZ9Rrv.mjs';
+import { a as InvalidUseFormConfigError } from './attaform-dev.Dr2YzS5B.mjs';
+import { u as useForm$2 } from './attaform-dev.D2I8e_Mm.mjs';
+import { u as useForm$1 } from './attaform-dev.oYrkP9dj.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform-dev.6qxD-Yqo.mjs';
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -21,12 +21,12 @@ function useForm(configuration) {
   return useForm$2(configuration);
 }
 
-const fieldMeta = fieldMetaStore;
+const fieldMeta = installingFieldMetaStore;
 function withMeta(schema, payload) {
   const target = schema;
   const existing = getFieldMetaForSchema(target) ?? {};
   const cloned = cloneSchema(schema);
-  fieldMetaStore.add(cloned, { ...existing, ...payload });
+  installingFieldMetaStore.add(cloned, { ...existing, ...payload });
   return cloned;
 }
 function cloneSchema(schema) {
@@ -39,4 +39,3 @@ function cloneSchema(schema) {
 }
 
 export { fieldMeta as f, useForm as u, withMeta as w };
-//# sourceMappingURL=attaform.Dc1mx48r.mjs.map

package/dist/dev/shared/attaform-dev.BXE2cr0L.mjs

@@ -0,0 +1,220 @@
+import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform-dev.Dr2YzS5B.mjs';
+import { shallowReactive, getCurrentInstance, inject } from 'vue';
+
+function detectSSR(options = {}) {
+  if (options.ssr !== void 0) return options.ssr;
+  return typeof window === "undefined" && typeof document === "undefined";
+}
+
+const kAttaformRegistry = /* @__PURE__ */ Symbol.for("attaform:registry");
+const kAttaformAncestorWizard = /* @__PURE__ */ Symbol.for(
+  "attaform:ancestor-wizard"
+);
+const kAttaformWizardActiveStepResolver = /* @__PURE__ */ Symbol.for(
+  "attaform:wizard-active-step-resolver"
+);
+const kFormContext = /* @__PURE__ */ Symbol.for("attaform:form-context");
+const kFormInstanceId = /* @__PURE__ */ Symbol.for("attaform:form-instance-id");
+function createRegistry(options = {}) {
+  const ssr = detectSSR(options);
+  const defaults = Object.freeze({ ...options.defaults ?? {} });
+  const forms = shallowReactive(/* @__PURE__ */ new Map());
+  const wizards = shallowReactive(/* @__PURE__ */ new Map());
+  const pendingHydration = shallowReactive(/* @__PURE__ */ new Map());
+  const consumers = /* @__PURE__ */ new Map();
+  const pendingEvictions = /* @__PURE__ */ new Map();
+  function cancelPendingEviction(key) {
+    const pending = pendingEvictions.get(key);
+    if (pending === void 0) return;
+    pending.cancelled = true;
+    pendingEvictions.delete(key);
+  }
+  function trackConsumer(key) {
+    cancelPendingEviction(key);
+    consumers.set(key, (consumers.get(key) ?? 0) + 1);
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      const remaining = (consumers.get(key) ?? 1) - 1;
+      if (remaining > 0) {
+        consumers.set(key, remaining);
+        return;
+      }
+      consumers.delete(key);
+      const token = { cancelled: false };
+      pendingEvictions.set(key, token);
+      queueMicrotask(() => {
+        if (token.cancelled) return;
+        if (pendingEvictions.get(key) !== token) return;
+        pendingEvictions.delete(key);
+        const state = forms.get(key);
+        forms.delete(key);
+        if (state === void 0) return;
+        state.dispose();
+      });
+    };
+  }
+  const wizardConsumers = /* @__PURE__ */ new Map();
+  const pendingWizardEvictions = /* @__PURE__ */ new Map();
+  function cancelPendingWizardEviction(key) {
+    const pending = pendingWizardEvictions.get(key);
+    if (pending === void 0) return;
+    pending.cancelled = true;
+    pendingWizardEvictions.delete(key);
+  }
+  function trackWizardConsumer(key) {
+    cancelPendingWizardEviction(key);
+    wizardConsumers.set(key, (wizardConsumers.get(key) ?? 0) + 1);
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      const remaining = (wizardConsumers.get(key) ?? 1) - 1;
+      if (remaining > 0) {
+        wizardConsumers.set(key, remaining);
+        return;
+      }
+      wizardConsumers.delete(key);
+      const token = { cancelled: false };
+      pendingWizardEvictions.set(key, token);
+      queueMicrotask(() => {
+        if (token.cancelled) return;
+        if (pendingWizardEvictions.get(key) !== token) return;
+        pendingWizardEvictions.delete(key);
+        wizards.delete(key);
+      });
+    };
+  }
+  const prefetchEnqueued = /* @__PURE__ */ new Set();
+  const prefetchSkipped = /* @__PURE__ */ new Set();
+  function enqueuePrefetch(key) {
+    prefetchEnqueued.add(key);
+  }
+  function skipPrefetch(key) {
+    prefetchSkipped.add(key);
+  }
+  function shouldPrefetch(key) {
+    return prefetchEnqueued.has(key) && !prefetchSkipped.has(key);
+  }
+  return {
+    forms,
+    wizards,
+    pendingHydration,
+    ssr,
+    defaults,
+    trackConsumer,
+    trackWizardConsumer,
+    enqueuePrefetch,
+    skipPrefetch,
+    shouldPrefetch
+  };
+}
+function useRegistry() {
+  const instance = getCurrentInstance();
+  if (instance === null) {
+    throw new OutsideSetupError();
+  }
+  const registry = inject(kAttaformRegistry, null);
+  if (registry === null) {
+    throw new RegistryNotInstalledError();
+  }
+  return registry;
+}
+function getRegistryFromApp(app) {
+  const registry = app._attaform;
+  if (registry === void 0) {
+    throw new RegistryNotInstalledError();
+  }
+  return registry;
+}
+function attachRegistryToApp(app, registry) {
+  app.provide(kAttaformRegistry, registry);
+  app._attaform = registry;
+}
+
+function installAttaformOnApp(app, options, source) {
+  if (app._attaform !== void 0) {
+    if (source === "explicit") {
+      console.warn(
+        "[attaform] createAttaform() install was called twice on the same app; the second call is a no-op. Likely cause: registering the plugin via both the Nuxt module AND a manual `app.use(...)`."
+      );
+    }
+    return app._attaform;
+  }
+  const registry = createRegistry(options);
+  attachRegistryToApp(app, registry);
+  if (options.devtools !== false && !registry.ssr) {
+    void (async () => {
+      try {
+        const { setupAttaformDevtools } = await import('../chunks/devtools.mjs');
+        await setupAttaformDevtools(app, registry);
+      } catch {
+      }
+    })();
+  }
+  return registry;
+}
+function ensureAttaformInstalled(app) {
+  return installAttaformOnApp(app, {}, "lazy");
+}
+function createAttaform(options = {}) {
+  const plugin = {
+    install(app) {
+      installAttaformOnApp(app, options, "explicit");
+    }
+  };
+  return plugin;
+}
+
+const ATTAFORM_STATE_VERSION = 1;
+function renderAttaformState(app) {
+  const registry = getRegistryFromApp(app);
+  const forms = [];
+  for (const [key, state] of registry.forms) {
+    const transientList = [];
+    for (const pk of state.blankPaths) {
+      const d = pathKeyToDotted(pk);
+      if (d !== null) transientList.push(d);
+    }
+    forms.push([
+      key,
+      {
+        form: state.form.value,
+        // The wire shape stays two per-source arrays; the tagged store
+        // splits at the boundary and the client replays each side into
+        // its cell half.
+        schemaErrors: [...state.errorCells.entries()].filter(([, cell]) => cell.schema.length > 0).map(([key2, cell]) => [key2, cell.schema]),
+        userErrors: [...state.errorCells.entries()].filter(([, cell]) => cell.user.length > 0).map(([key2, cell]) => [key2, cell.user]),
+        fields: Array.from(state.fields.entries()),
+        ...transientList.length > 0 ? { blankPaths: transientList } : {}
+      }
+    ]);
+  }
+  return { v: ATTAFORM_STATE_VERSION, forms };
+}
+function hydrateAttaformState(app, payload) {
+  if (!isHydratableEnvelope(payload)) {
+    {
+      let got = payload;
+      if (payload !== null && typeof payload === "object") {
+        got = "v" in payload ? payload.v : void 0;
+      }
+      console.warn(
+        `[attaform] hydrateAttaformState: payload version mismatch (expected ${ATTAFORM_STATE_VERSION}, got ${String(got)}). Skipping hydration \u2014 forms will construct fresh. This usually means the SSR bundle is on a different attaform version than the client (rolling deploy / stale cache).`
+      );
+    }
+    return;
+  }
+  const registry = getRegistryFromApp(app);
+  for (const [key, data] of payload.forms) {
+    registry.pendingHydration.set(key, data);
+  }
+}
+function isHydratableEnvelope(payload) {
+  return payload !== null && typeof payload === "object" && "v" in payload && payload.v === ATTAFORM_STATE_VERSION && "forms" in payload && Array.isArray(payload.forms);
+}
+
+const DEVTOOLS_WINDOW_KEY = "__attaform_devtools__";
+
+export { DEVTOOLS_WINDOW_KEY as D, createRegistry as a, kAttaformWizardActiveStepResolver as b, createAttaform as c, kFormContext as d, ensureAttaformInstalled as e, kFormInstanceId as f, getRegistryFromApp as g, hydrateAttaformState as h, kAttaformAncestorWizard as i, kAttaformRegistry as k, renderAttaformState as r, useRegistry as u };