attaform 0.28.0 → 0.29.0

package/dist/shared/{attaform.Cs2Rbdlo.mjs → attaform.BK0cgu2K.mjs}

@@ -1,4 +1,4 @@
-import { NodeTypes, createCompoundExpression, createSimpleExpression, ElementTypes, processExpression } from '@vue/compiler-core';
+import { NodeTypes, ElementTypes, createCompoundExpression, createSimpleExpression, processExpression } from '@vue/compiler-core';
 import { S as SSR_COMPONENT_HOST_MODIFIER, V as V_REGISTER_COMPILED_MODIFIER } from './attaform.KvlEedlF.mjs';
 
 function getSummarizedProps(node) {
@@ -40,6 +40,10 @@ function removePropsByName(props, propNames) {
     props.splice(index, 1);
   }
 }
+function toExpressionArray(value) {
+  if (value === void 0) return void 0;
+  return Array.isArray(value) ? value : [value];
+}
 function isExactKey(summarizedKey, name) {
   return summarizedKey === name || summarizedKey === `"${name}"`;
 }
@@ -64,54 +68,13 @@ function flattenExpression(exp) {
   return out;
 }
 
-function generateEqualityExpression$1(selectValue, optionValue, previousOptionExpressions) {
-  const multipleExpression = previousOptionExpressions?.[0];
-  if (multipleExpression === void 0) {
-    throw new Error(
-      "Programming error: `multiple` expression for `select` node not generated while transforming AST"
-    );
-  }
-  const optExpressions = previousOptionExpressions.slice(1);
-  const noMultipleOptExpressions = optExpressions.reduce(
-    (acc, curr, index) => {
-      if (index === 0) {
-        acc.push("(");
-      }
-      acc.push(...curr);
-      if (index < optExpressions.length - 1) {
-        acc.push(" || ");
-      }
-      if (index === optExpressions.length - 1) {
-        acc.push(")");
-      }
-      return acc;
-    },
-    []
-  );
+function generateEqualityExpression$1(selectValue, optionValue, multipleExpression) {
   const selectValueArr = Array.isArray(selectValue) ? selectValue : [selectValue];
   const optionValueArr = Array.isArray(optionValue) ? optionValue : [optionValue];
   function getImplicitTrueMultipleExpression(expression) {
     if (expression.length === 1 && expression[0] === "") return [`true`];
     return expression;
   }
-  previousOptionExpressions.push(["(", ...selectValueArr, ") === (", ...optionValueArr, ")"]);
-  if (!noMultipleOptExpressions.length) {
-    return [
-      "(",
-      ...getImplicitTrueMultipleExpression(multipleExpression),
-      `) ? ((`,
-      ...selectValueArr,
-      `)?.innerRef?.value?.findIndex?.(el => el === (`,
-      ...optionValueArr,
-      `)) > -1) : (typeof (`,
-      ...selectValueArr,
-      `)?.innerRef?.value !== 'object' && String((`,
-      ...selectValueArr,
-      `)?.innerRef?.value) === String((`,
-      ...optionValueArr,
-      `)))`
-    ];
-  }
   return [
     "(",
     ...getImplicitTrueMultipleExpression(multipleExpression),
@@ -119,16 +82,13 @@ function generateEqualityExpression$1(selectValue, optionValue, previousOptionEx
     ...selectValueArr,
     `)?.innerRef?.value?.findIndex?.(el => el === (`,
     ...optionValueArr,
-    `)) > -1) : ((`,
-    ...noMultipleOptExpressions,
-    // if true, we already found the relevant option
-    `) ? false : (typeof (`,
+    `)) > -1) : (typeof (`,
     ...selectValueArr,
-    `)?.innerRef?.value !== 'object' && String((`,
+    `)?.innerRef?.value !== 'object' && (`,
     ...selectValueArr,
-    `)?.innerRef?.value) === String((`,
+    `)?.displayValue?.value === String((`,
     ...optionValueArr,
-    `))))`
+    `)))`
   ];
 }
 function extractMultipleFromSelectSummarizedProps(props) {
@@ -143,7 +103,7 @@ function extractMultipleFromSelectSummarizedProps(props) {
   const value = props[priorityIndex]?.value;
   return typeof value === "string" ? value.replace(/'|"/g, "") : value ?? "true";
 }
-const RECURSABLE_NODE_TYPES$1 = /* @__PURE__ */ new Set([
+const RECURSABLE_NODE_TYPES = /* @__PURE__ */ new Set([
   NodeTypes.ELEMENT,
   NodeTypes.FOR,
   NodeTypes.IF,
@@ -170,6 +130,57 @@ function inferOptionValueFromChildren(node) {
   const text = only.content.trim();
   return JSON.stringify(text);
 }
+const pendingOptionBindings = /* @__PURE__ */ new WeakMap();
+function applyPendingOptionBinding(node, pending) {
+  const optionProps = getSummarizedProps(node);
+  const valueIndex = optionProps.findIndex((p) => isExactKey(p.key, "value"));
+  let optionValueSummarizedProp;
+  if (valueIndex >= 0 && valueIndex < optionProps.length) {
+    optionValueSummarizedProp = optionProps[valueIndex];
+  } else {
+    const fallback = inferOptionValueFromChildren(node);
+    if (fallback === null) {
+      return;
+    }
+    optionValueSummarizedProp = { key: "value", value: fallback };
+  }
+  const props = node.props;
+  const snapshot = [...props];
+  try {
+    removePropsByName(props, ["selected"]);
+    const authorSelectedArr = toExpressionArray(
+      optionProps.find((p) => isExactKey(p.key, "selected"))?.value
+    );
+    const registerArr = toExpressionArray(pending.registerValue) ?? ["undefined"];
+    const boundExpression = generateEqualityExpression$1(
+      pending.registerValue,
+      optionValueSummarizedProp?.value ?? "undefined",
+      pending.multiple
+    );
+    props.push({
+      arg: createSimpleExpression("selected", true),
+      exp: createCompoundExpression(
+        authorSelectedArr === void 0 ? boundExpression : [
+          "((",
+          ...registerArr,
+          ") == null ? (",
+          ...authorSelectedArr,
+          ") : (",
+          ...boundExpression,
+          "))"
+        ]
+      ),
+      name: "bind",
+      modifiers: [],
+      type: NodeTypes.DIRECTIVE,
+      loc: node.loc
+    });
+  } catch (err) {
+    props.length = 0;
+    props.push(...snapshot);
+    console.error("[attaform] component-bridge transform: option binding failed, skipping:", err);
+  }
+}
 const componentBridgeTransform = (node, context) => {
   const snapshots = [];
   const snapshotProps = (target) => {
@@ -177,51 +188,33 @@ const componentBridgeTransform = (node, context) => {
     snapshots.push({ target, snapshot: [...target] });
   };
   try {
-    let traverseSelectNode = function(_node, previousOptionExpressions2) {
+    let traverseSelectNode = function(_node, multipleExpression2) {
       const isOption = _node.type === NodeTypes.ELEMENT && _node.tag === "option";
       if (!isOption) {
-        if (!RECURSABLE_NODE_TYPES$1.has(_node.type)) return;
+        if (!RECURSABLE_NODE_TYPES.has(_node.type)) return;
         const hasChildren = "children" in _node;
         if (!hasChildren) return;
         for (const child of _node.children) {
           if (typeof child === "symbol" || typeof child === "string") continue;
           if (child.type === NodeTypes.SIMPLE_EXPRESSION) continue;
-          traverseSelectNode(child, previousOptionExpressions2);
+          traverseSelectNode(child, multipleExpression2);
         }
         return;
       }
       hasSlottedOptions = true;
-      const optionProps = getSummarizedProps(_node);
-      const valueIndex = optionProps.findIndex((p) => isExactKey(p.key, "value"));
-      let optionValueSummarizedProp;
-      if (valueIndex >= 0 && valueIndex < optionProps.length) {
-        optionValueSummarizedProp = optionProps[valueIndex];
-      } else {
-        const fallback = inferOptionValueFromChildren(_node);
-        if (fallback === null) {
-          return;
-        }
-        optionValueSummarizedProp = { key: "value", value: fallback };
-      }
-      const props = _node.props;
-      snapshotProps(props);
-      removePropsByName(props, ["selected"]);
-      const newProp = {
-        arg: createSimpleExpression("selected", true),
-        exp: createCompoundExpression(
-          generateEqualityExpression$1(
-            registerSummarizedProp?.value ?? "undefined",
-            optionValueSummarizedProp?.value ?? "undefined",
-            previousOptionExpressions2
-          )
-        ),
-        name: "bind",
-        modifiers: [],
-        type: NodeTypes.DIRECTIVE,
-        loc: _node.loc
-      };
-      props.push(newProp);
+      pendingOptionBindings.set(_node, {
+        registerValue: registerSummarizedProp?.value ?? "undefined",
+        multiple: multipleExpression2
+      });
     };
+    if (node.type === NodeTypes.ELEMENT && node.tagType === ElementTypes.ELEMENT) {
+      const pending = pendingOptionBindings.get(node);
+      if (pending !== void 0) {
+        pendingOptionBindings.delete(node);
+        applyPendingOptionBinding(node, pending);
+        return;
+      }
+    }
     const isSelect = node.type === NodeTypes.ELEMENT && node.tag === "select";
     const isCustomComponent = node.type === NodeTypes.ELEMENT && node.tagType === ElementTypes.COMPONENT;
     const isKebabCustomElement = node.type === NodeTypes.ELEMENT && node.tagType === ElementTypes.ELEMENT && node.tag.includes("-") && !NATIVE_FORM_TAGS.has(node.tag);
@@ -233,25 +226,32 @@ const componentBridgeTransform = (node, context) => {
     const registerSummarizedProp = selectSummarizedProps[registerIndex];
     const selectLoc = node.loc;
     let hasSlottedOptions = false;
-    const multipleExpression = extractMultipleFromSelectSummarizedProps(selectSummarizedProps);
-    const previousOptionExpressions = typeof multipleExpression === "string" ? [[multipleExpression]] : [multipleExpression];
+    const rawMultipleExpression = extractMultipleFromSelectSummarizedProps(selectSummarizedProps);
+    const multipleExpression = typeof rawMultipleExpression === "string" ? [rawMultipleExpression] : rawMultipleExpression;
     for (const child of node.children) {
-      traverseSelectNode(child, previousOptionExpressions);
+      traverseSelectNode(child, multipleExpression);
     }
-    const isStaticallyNonMultiple = multipleExpression === "false";
+    const isStaticallyNonMultiple = rawMultipleExpression === "false";
     const isComponentHost = isCustomComponent || isKebabCustomElement;
     const isSelectLikeHost = isSelect || isComponentHost && hasSlottedOptions;
     const isPlainComponentHost = isComponentHost && !hasSlottedOptions;
     const selectProps = node.props;
+    const authorSelectValueArr = toExpressionArray(
+      selectSummarizedProps.find((p) => isExactKey(p.key, "value"))?.value
+    );
     snapshotProps(selectProps);
     removePropsByName(selectProps, ["value"]);
     if (isStaticallyNonMultiple && isSelectLikeHost) {
       const valuePropExpArray = Array.isArray(registerSummarizedProp?.value) ? registerSummarizedProp.value : [registerSummarizedProp?.value ?? "undefined"];
-      const initExpression = createCompoundExpression([
-        "(",
-        ...valuePropExpArray,
-        ")?.displayValue.value"
-      ]);
+      const initExpression = createCompoundExpression(
+        authorSelectValueArr === void 0 ? ["(", ...valuePropExpArray, ")?.displayValue.value"] : [
+          "((",
+          ...valuePropExpArray,
+          ")?.displayValue.value ?? (",
+          ...authorSelectValueArr,
+          "))"
+        ]
+      );
       const simpleExpression = createSimpleExpression(flattenExpression(initExpression), false);
       let outputExp;
       try {
@@ -470,26 +470,41 @@ const inputTextAreaNodeTransform = (node) => {
       const isStaticRadio = typeProp !== void 0 && isStaticTypeOneOf(typeProp.value, ["radio"]);
       const isDynamicType = typeProp !== void 0 && isDynamicTypeValue(typeProp.value);
       const keepStaticValue = isStaticCheckbox || isStaticRadio || isDynamicType;
+      const authorCheckedProp = elementProps.find((p) => isExactKey(p.key, "checked"));
+      const authorValueProp = keepStaticValue ? void 0 : elementProps.find((p) => isExactKey(p.key, "value"));
       removePropsByName(props, keepStaticValue ? ["checked"] : ["checked", "value"]);
       const registerValueArr = Array.isArray(registerSummarizedProp2.value) ? registerSummarizedProp2.value : [registerSummarizedProp2.value];
-      const valueExpression = createCompoundExpression([
-        "(",
-        ...registerValueArr,
-        ")?.displayValue?.value"
-      ]);
+      const authorValueArr = toExpressionArray(authorValueProp?.value);
+      const valueExpression = createCompoundExpression(
+        authorValueArr === void 0 ? ["(", ...registerValueArr, ")?.displayValue?.value"] : ["((", ...registerValueArr, ")?.displayValue?.value ?? (", ...authorValueArr, "))"]
+      );
       const trueValueIndex = elementProps.findIndex((p) => isExactKey(p.key, "true-value"));
       const trueValueProp = elementProps[trueValueIndex];
       const scalarTarget = isStaticCheckbox ? trueValueProp !== void 0 ? trueValueProp.value : "true" : elementValueSummarizedProp2.value;
-      const coreExpression = [
-        "(",
-        ...elementSelectionLabelExpression.children,
-        ") === 'checked' ? (",
-        // resolves to a boolean
+      const authorCheckedArr = toExpressionArray(authorCheckedProp?.value);
+      const checkedExpression = authorCheckedArr === void 0 ? generateEqualityExpression(
+        registerSummarizedProp2.value,
+        elementValueSummarizedProp2.value,
+        scalarTarget
+      ) : [
+        "((",
+        ...registerValueArr,
+        ") == null ? (",
+        ...authorCheckedArr,
+        ") : (",
         ...generateEqualityExpression(
           registerSummarizedProp2.value,
           elementValueSummarizedProp2.value,
           scalarTarget
         ),
+        "))"
+      ];
+      const coreExpression = [
+        "(",
+        ...elementSelectionLabelExpression.children,
+        ") === 'checked' ? (",
+        // resolves to a boolean
+        ...checkedExpression,
         ") : (",
         // resolves to the provided register value
         ...valueExpression.children,
@@ -562,22 +577,10 @@ const inputTextAreaNodeTransform = (node) => {
   }
 };
 
-const RECURSABLE_NODE_TYPES = /* @__PURE__ */ new Set([
-  NodeTypes.ELEMENT,
-  NodeTypes.FOR,
-  NodeTypes.IF,
-  NodeTypes.IF_BRANCH
-]);
-function findRedundantStateBinding(props, stateNames) {
+function findRedundantStateBinding(props) {
   for (const prop of props) {
-    if (prop.type === NodeTypes.ATTRIBUTE) {
-      if (stateNames.includes(prop.name)) return prop.name;
-      continue;
-    }
+    if (prop.type === NodeTypes.ATTRIBUTE) continue;
     if (prop.name === "model") return "v-model";
-    if (prop.name === "bind" && prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic && stateNames.includes(prop.arg.content)) {
-      return `:${prop.arg.content}`;
-    }
   }
   return null;
 }
@@ -602,42 +605,23 @@ function emitRedundantWarning(tag, binding) {
     `[attaform] \`${binding}\` is redundant beside v-register on <${tag}>. v-register already drives this field's value, so keep v-register alone and drop \`${binding}\`. (An identity \`:value\` on a radio or <option> is expected and stays silent.)`
   );
 }
-function walkOptionsForSelected(selectNode) {
-  const visit = (candidate) => {
-    if (candidate.type === NodeTypes.ELEMENT && candidate.tag === "option") {
-      const found = findRedundantStateBinding(candidate.props, ["selected"]);
-      if (found !== null) emitRedundantWarning("option", found);
-      return;
-    }
-    if (!RECURSABLE_NODE_TYPES.has(candidate.type)) return;
-    if (!("children" in candidate)) return;
-    for (const child of candidate.children) {
-      if (typeof child === "string" || typeof child === "symbol") continue;
-      if (child.type === NodeTypes.SIMPLE_EXPRESSION) continue;
-      visit(child);
-    }
-  };
-  for (const child of selectNode.children) visit(child);
-}
 function warnIfRedundant(node) {
   if (node.tagType !== ElementTypes.ELEMENT) return;
   const tag = node.tag;
   if (tag === "select") {
-    const found2 = findRedundantStateBinding(node.props, ["value"]);
+    const found2 = findRedundantStateBinding(node.props);
     if (found2 !== null) emitRedundantWarning("select", found2);
-    walkOptionsForSelected(node);
     return;
   }
   if (tag === "textarea") {
-    const found2 = findRedundantStateBinding(node.props, ["value"]);
+    const found2 = findRedundantStateBinding(node.props);
     if (found2 !== null) emitRedundantWarning("textarea", found2);
     return;
   }
   if (tag !== "input") return;
   const kind = classifyInput(node.props);
   if (kind === "dynamic" || kind === "file") return;
-  const stateNames = kind === "checkbox" || kind === "radio" ? ["checked"] : ["value"];
-  const found = findRedundantStateBinding(node.props, stateNames);
+  const found = findRedundantStateBinding(node.props);
   if (found !== null) emitRedundantWarning("input", found);
 }
 const redundantBindingWarnTransform = (node) => {

package/dist/shared/{attaform.D6DCnnQu.mjs → attaform.BndjUUYX.mjs}

@@ -1,7 +1,7 @@
-import { a as InvalidUseFormConfigError } from './attaform.wfY8XFvm.mjs';
-import { u as useForm$2 } from './attaform.CJP3RkGa.mjs';
-import { u as useForm$1 } from './attaform.NLmerepI.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform.C09fpdLS.mjs';
+import { a as InvalidUseFormConfigError } from './attaform.CZYt_5N_.mjs';
+import { u as useForm$2 } from './attaform.D1fnTifF.mjs';
+import { u as useForm$1 } from './attaform.C2MVyuxC.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform.B0dKL8ST.mjs';
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;

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

@@ -24,6 +24,14 @@ function canonicalStringify(value, seen = /* @__PURE__ */ new WeakSet()) {
     try {
       if (value instanceof Date) return `date:${value.getTime()}`;
       if (value instanceof RegExp) return `regex:${String(value)}`;
+      if (value instanceof Map) {
+        const entries2 = [...value].map(([k, v]) => `${canonicalStringify(k, seen)}=>${canonicalStringify(v, seen)}`).sort();
+        return `map:[${entries2.join(",")}]`;
+      }
+      if (value instanceof Set) {
+        const members = [...value].map((v) => canonicalStringify(v, seen)).sort();
+        return `set:[${members.join(",")}]`;
+      }
       const entries = Object.entries(obj).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalStringify(v, seen)}`);
       return `{${entries.join(",")}}`;
     } finally {

package/dist/shared/{attaform.NLmerepI.mjs → attaform.C2MVyuxC.mjs}

@@ -1,30 +1,9 @@
-import { o as humanize, h as useAbstractForm } from './attaform.B8k8JrmK.mjs';
-import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.wfY8XFvm.mjs';
-import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, b as buildFieldMetaPathMap, a as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform.C09fpdLS.mjs';
+import { q as humanize, h as useAbstractForm } from './attaform.CZMAYwSK.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.CZYt_5N_.mjs';
+import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, b as buildFieldMetaPathMap, a as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform.B0dKL8ST.mjs';
+import { c as callConsumerSchemaFn } from './attaform.Cvao8bW5.mjs';
 import { z } from 'zod';
 
-function zodIssuesToValidationErrors(issues) {
-  return issues.map((issue) => {
-    let code;
-    if (typeof issue.code === "string" && issue.code.length > 0) {
-      code = `zod:${issue.code}`;
-    } else {
-      code = "zod:unknown";
-    }
-    return {
-      message: issue.message,
-      // Adapter-side paths stay schema-relative — the validation
-      // pipeline in `create-form-store.ts` prepends the parent path
-      // to absolutise, then routes form-level (absolute path length 0)
-      // entries to the empty-string bucket at storage time.
-      path: issue.path.map((seg) => typeof seg === "number" ? seg : String(seg)),
-      code
-    };
-  });
-}
-class UnsupportedSchemaError extends AttaformError {
-}
-
 function readDef(schema) {
   if (schema === null || typeof schema !== "object") return void 0;
   return schema.def;
@@ -103,6 +82,8 @@ function getRecordValueType(schema) {
   const def = readDef(schema);
   return def?.valueType;
 }
+const getMapKeyType = getRecordKeyType;
+const getMapValueType = getRecordValueType;
 function getTupleItems(schema) {
   const def = readDef(schema);
   return def?.items ?? [];
@@ -149,7 +130,7 @@ function unwrapLazy(schema) {
   const def = readDef(schema);
   const getter = def?.getter;
   if (typeof getter !== "function") return void 0;
-  return getter();
+  return callConsumerSchemaFn(() => getter(), void 0);
 }
 function getLazyGetter(schema) {
   const def = readDef(schema);
@@ -167,11 +148,9 @@ function getCatchDefault(schema) {
   const def = readDef(schema);
   const cv = def?.catchValue;
   if (typeof cv !== "function") return void 0;
-  try {
-    return cv({ error: new Error("atta:default-values"), input: void 0 });
-  } catch {
-    return void 0;
-  }
+  return callConsumerSchemaFn(
+    () => cv({ error: new Error("atta:default-values"), input: void 0 }),
+    void 0);
 }
 function hasCatchValue(schema) {
   const def = readDef(schema);
@@ -179,7 +158,7 @@ function hasCatchValue(schema) {
 }
 function getDefaultValue(schema) {
   const def = readDef(schema);
-  return def?.defaultValue;
+  return callConsumerSchemaFn(() => def?.defaultValue, void 0);
 }
 function getNativeEnumValues(_schema) {
   return void 0;
@@ -328,123 +307,6 @@ function isAsyncCheck(check) {
   return fn.constructor.name === "AsyncFunction";
 }
 
-const UNSUPPORTED = [
-  "promise",
-  "custom",
-  "template-literal",
-  "map",
-  "symbol",
-  "function"
-];
-function labelPath(path) {
-  return path.length === 0 ? "<root>" : path.join(".");
-}
-function assertSupportedKinds(schema, path = [], lazyGetters = []) {
-  const kind = kindOf(schema);
-  if (UNSUPPORTED.includes(kind)) {
-    throw new UnsupportedSchemaError(
-      `[attaform] AF02 attaform.dev/e/af02 '${kind}' at '${labelPath(path)}'`
-    );
-  }
-  switch (kind) {
-    case "object": {
-      const shape = getObjectShape(schema);
-      for (const [key, sub] of Object.entries(shape)) {
-        assertSupportedKinds(sub, [...path, key], lazyGetters);
-      }
-      return;
-    }
-    case "array":
-      assertSupportedKinds(getArrayElement(schema), [...path, "*"], lazyGetters);
-      return;
-    case "set":
-      assertSupportedKinds(getSetValueType(schema), [...path, "*"], lazyGetters);
-      return;
-    case "record":
-      assertSupportedKinds(getRecordValueType(schema), [...path, "*"], lazyGetters);
-      return;
-    case "tuple": {
-      const items = getTupleItems(schema);
-      items.forEach((item, i) => assertSupportedKinds(item, [...path, String(i)], lazyGetters));
-      return;
-    }
-    case "union": {
-      const options = getUnionOptions(schema);
-      options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
-      return;
-    }
-    case "discriminated-union": {
-      const options = getDiscriminatedOptions(schema);
-      options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
-      return;
-    }
-    case "optional":
-    case "nullable":
-    case "default":
-    case "readonly":
-    case "catch": {
-      const inner = unwrapInner(schema);
-      if (inner !== void 0) assertSupportedKinds(inner, path, lazyGetters);
-      return;
-    }
-    case "pipe": {
-      const inner = unwrapPipe(schema);
-      if (inner !== void 0) assertSupportedKinds(inner, path, lazyGetters);
-      return;
-    }
-    case "lazy": {
-      const getter = getLazyGetter(schema);
-      if (getter !== void 0 && lazyGetters.includes(getter)) return;
-      const inner = unwrapLazy(schema);
-      if (inner !== void 0) {
-        assertSupportedKinds(
-          inner,
-          path,
-          getter === void 0 ? lazyGetters : [...lazyGetters, getter]
-        );
-      }
-      return;
-    }
-    case "intersection": {
-      const left = getIntersectionLeft(schema);
-      const right = getIntersectionRight(schema);
-      if (left !== void 0) assertSupportedKinds(left, [...path, "left"], lazyGetters);
-      if (right !== void 0) assertSupportedKinds(right, [...path, "right"], lazyGetters);
-      return;
-    }
-    // Leaves: nothing to descend into.
-    case "string":
-    case "number":
-    case "boolean":
-    case "bigint":
-    case "date":
-    case "enum":
-    case "literal":
-    case "null":
-    case "undefined":
-    case "nan":
-    case "any":
-    case "unknown":
-    case "void":
-    case "never":
-    case "promise":
-    case "custom":
-    case "template-literal":
-    case "transform":
-    case "file":
-    case "map":
-    case "symbol":
-    case "function":
-      return;
-    default: {
-      const _exhaustive = kind;
-      throw new Error(
-        `[attaform] AF03 attaform.dev/e/af03 '${_exhaustive}'`
-      );
-    }
-  }
-}
-
 function unwrapToDiscriminatedUnion(schema) {
   let current = schema;
   for (let i = 0; i < 64; i++) {
@@ -471,6 +333,26 @@ function unwrapToDiscriminatedUnion(schema) {
   return void 0;
 }
 
+function zodIssuesToValidationErrors(issues) {
+  return issues.map((issue) => {
+    let code;
+    if (typeof issue.code === "string" && issue.code.length > 0) {
+      code = `zod:${issue.code}`;
+    } else {
+      code = "zod:unknown";
+    }
+    return {
+      message: issue.message,
+      // Adapter-side paths stay schema-relative — the validation
+      // pipeline in `create-form-store.ts` prepends the parent path
+      // to absolutise, then routes form-level (absolute path length 0)
+      // entries to the empty-string bucket at storage time.
+      path: issue.path.map((seg) => typeof seg === "number" ? seg : String(seg)),
+      code
+    };
+  });
+}
+
 const V4_INTROSPECTOR = {
   kindOf: (schema) => kindOf(schema),
   getObjectShape: (schema) => getObjectShape(schema),
@@ -492,6 +374,8 @@ const V4_INTROSPECTOR = {
   getSetValueType: (schema) => kindOf(schema) === "set" ? getSetValueType(schema) : void 0,
   getRecordKeyType: (schema) => kindOf(schema) === "record" ? getRecordKeyType(schema) : void 0,
   getRecordValueType: (schema) => kindOf(schema) === "record" ? getRecordValueType(schema) : void 0,
+  getMapKeyType: (schema) => kindOf(schema) === "map" ? getMapKeyType(schema) : void 0,
+  getMapValueType: (schema) => kindOf(schema) === "map" ? getMapValueType(schema) : void 0,
   getUnionOptions,
   getIntersectionLeft,
   getIntersectionRight,
@@ -697,6 +581,13 @@ function unwrapStructuralWrappers(schema) {
   }
   return current;
 }
+function assertKeyedRoot(rootSchema) {
+  const kind = kindOf(peelAllWrappers(rootSchema));
+  if (kind === "object" || kind === "record" || kind === "discriminated-union") return;
+  throw new AttaformError(
+    `[attaform] AF15 attaform.dev/e/af15 '${kind}'`
+  );
+}
 function peelAllWrappers(schema) {
   let current = schema;
   for (let i = 0; i < 64; i++) {
@@ -770,7 +661,7 @@ function isLeafRequired(schema, depth = 0) {
 }
 function zodV4Adapter(rootSchema) {
   assertZodVersion(rootSchema);
-  assertSupportedKinds(rootSchema);
+  assertKeyedRoot(rootSchema);
   return (formKey, options) => createAbstractSchema(
     rootSchema,
     V4_INTROSPECTOR,
@@ -917,4 +808,4 @@ function useForm(configuration) {
   });
 }
 
-export { UnsupportedSchemaError as U, assertZodVersion as a, getIntersectionRight as b, unwrapLazy as c, unwrapInner as d, unwrapPipe as e, getDiscriminator as f, getIntersectionLeft as g, getDiscriminatedOptions as h, getUnionOptions as i, getRecordKeyType as j, kindOf as k, getRecordValueType as l, getTupleItems as m, getSetValueType as n, getArrayElement as o, getObjectShape as p, getEnumValues as q, getLiteralValues as r, getChecks as s, getCatchDefault as t, useForm as u, getDefaultValue as v, zodV4Adapter as z };
+export { assertZodVersion as a, getIntersectionRight as b, unwrapLazy as c, unwrapInner as d, unwrapPipe as e, getDiscriminator as f, getIntersectionLeft as g, getDiscriminatedOptions as h, getUnionOptions as i, getRecordKeyType as j, kindOf as k, getRecordValueType as l, getTupleItems as m, getSetValueType as n, getArrayElement as o, getObjectShape as p, getEnumValues as q, getLiteralValues as r, getChecks as s, getCatchDefault as t, useForm as u, getDefaultValue as v, zodV4Adapter as z };