attaform 0.28.0 → 0.29.0

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

@@ -1,16 +1,30 @@
-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';
+import { A as AttaformErrorCode, n as isPlainRecord, s as slimKindOf, o as crossCopyState } from './attaform-dev.DHuydLAC.mjs';
+import { e as canonicalizePath, h as SET_MEMBER_SEGMENT } from './attaform-dev.A-TpJW0B.mjs';
+import { a as safeOwnRead, b as safeAssign } from './attaform-dev.ButTkwHd.mjs';
 
 const PATH_SEPARATOR = ".";
+function isOpaqueKind(kind) {
+  return kind === "any" || kind === "unknown" || kind === "custom";
+}
 function createAbstractSchema(rootSchema, intro, services, formKey, options) {
   const maxRecursionDepth = options.maxRecursionDepth;
   const leafCache = /* @__PURE__ */ new Map();
   const preprocessOrCoerceCache = /* @__PURE__ */ new Map();
+  const opaqueLeafCache = /* @__PURE__ */ new Map();
   const discriminatorCache = /* @__PURE__ */ new Map();
+  const entryKeyKindCache = /* @__PURE__ */ new Map();
   let asyncValidationFlag = null;
   let containerRefineFlag = null;
   let discriminatedUnionFlag = null;
+  function mapKeySegmentKind(schema) {
+    const keyType = intro.getMapKeyType(schema);
+    if (keyType === void 0) return void 0;
+    const kinds = services.slimPrimitivesOf(keyType, maxRecursionDepth);
+    const string = kinds.has("string");
+    const number = kinds.has("number");
+    if (string === number) return void 0;
+    return string ? "string" : "number";
+  }
   function computeDiscriminator(path) {
     const candidates = path.length === 0 ? [rootSchema] : services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
     let matchedUnion;
@@ -102,6 +116,32 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       if (resolved.length === 0) return false;
       return resolved.every((s) => intro.kindOf(services.peelAllWrappers(s)) === "object");
     },
+    entryKeyKindAtPath(path) {
+      const cacheKey = canonicalizePath(path).key;
+      if (entryKeyKindCache.has(cacheKey)) return entryKeyKindCache.get(cacheKey);
+      const resolved = path.length === 0 ? [rootSchema] : services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
+      let answer;
+      const only = resolved.length === 1 ? resolved[0] : void 0;
+      if (only !== void 0) {
+        switch (intro.kindOf(services.peelAllWrappers(only))) {
+          case "array":
+          case "tuple":
+            answer = "number";
+            break;
+          case "object":
+          case "record":
+            answer = "string";
+            break;
+          case "map":
+            answer = mapKeySegmentKind(services.peelAllWrappers(only));
+            break;
+          default:
+            answer = void 0;
+        }
+      }
+      entryKeyKindCache.set(cacheKey, answer);
+      return answer;
+    },
     getSchemasAtPath(path) {
       const resolved = services.getNestedSchemasInSlimMode(rootSchema, path, maxRecursionDepth);
       if (resolved.length === 0) return [];
@@ -123,8 +163,9 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       const cacheKey = canonicalizePath(path).key;
       const cached = leafCache.get(cacheKey);
       if (cached !== void 0) return cached;
-      const prim = this.getSlimPrimitiveTypesAtPath(path);
-      const isLeaf = prim.size > 0 && !prim.has("object") && !prim.has("array") && !prim.has("map") && !prim.has("set");
+      const opaque = path.length > 0 && this.isOpaqueLeafAtPath(path);
+      const prim = opaque ? void 0 : this.getSlimPrimitiveTypesAtPath(path);
+      const isLeaf = opaque || prim !== void 0 && prim.size > 0 && !prim.has("object") && !prim.has("array") && !prim.has("map") && !prim.has("set");
       leafCache.set(cacheKey, isLeaf);
       return isLeaf;
     },
@@ -146,6 +187,17 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       preprocessOrCoerceCache.set(cacheKey, hit);
       return hit;
     },
+    isOpaqueLeafAtPath(path) {
+      const cacheKey = canonicalizePath(path).key;
+      const cached = opaqueLeafCache.get(cacheKey);
+      if (cached !== void 0) return cached;
+      const resolved = path.length === 0 ? [rootSchema] : services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
+      const opaque = resolved.length > 0 && resolved.every(
+        (candidate) => isOpaqueKind(intro.kindOf(services.peelAllWrappers(candidate)))
+      );
+      opaqueLeafCache.set(cacheKey, opaque);
+      return opaque;
+    },
     isRequiredAtPath(path) {
       if (path.length === 0) return true;
       const resolved = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
@@ -289,6 +341,7 @@ function walkPathSegments(schema, segments, intro, maxDepth, lazyDepth) {
       return inner === void 0 ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth);
     }
     case "set": {
+      if (head !== SET_MEMBER_SEGMENT) return [];
       const inner = intro.getSetValueType(schema);
       return inner === void 0 ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth);
     }
@@ -296,6 +349,10 @@ function walkPathSegments(schema, segments, intro, maxDepth, lazyDepth) {
       const inner = intro.getRecordValueType(schema);
       return inner === void 0 ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth);
     }
+    case "map": {
+      const inner = intro.getMapValueType(schema);
+      return inner === void 0 ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth);
+    }
     case "tuple": {
       const index = Number(head);
       if (!Number.isInteger(index)) return [];
@@ -349,11 +406,13 @@ function walkPathSegments(schema, segments, intro, maxDepth, lazyDepth) {
       const rightResults = right === void 0 ? [] : walkPathSegments(right, segments, intro, maxDepth, lazyDepth);
       return [...leftResults, ...rightResults];
     }
-    // Leaves — can't descend further. The unsupported kinds (`map` /
-    // `symbol` / `function` / `promise`) are rejected at adapter
-    // construction by `assertSupportedKinds`; falling through to `[]`
-    // keeps the walker defensive in case construction is skipped
-    // (e.g. a downstream test instantiates a sub-schema directly).
+    // Leaves — can't descend further. Opaque leaves (`any` /
+    // `unknown` / `custom`) land here too and `[]` is the truthful
+    // answer: the schema declares no sub-paths under them, so none are
+    // fabricated. `symbol` / `function` / `promise` hold a value
+    // without declaring anything inside it and land here for the same
+    // reason. No kind is refused at construction (#607), so this is
+    // the only branch they ever take.
     default:
       return [];
   }
@@ -461,6 +520,15 @@ function fixNode(schema, value, ctx, lazyDepth) {
       }
       return value;
     }
+    case "map": {
+      if (!(value instanceof Map)) return value;
+      const valueType = intro.getMapValueType(schema);
+      if (valueType === void 0) return value;
+      for (const [key, entry] of [...value]) {
+        value.set(key, fixNode(valueType, entry, ctx, lazyDepth));
+      }
+      return value;
+    }
     case "intersection": {
       const left = intro.getIntersectionLeft(schema);
       const right = intro.getIntersectionRight(schema);
@@ -684,58 +752,63 @@ function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth =
     }
     case "file":
       return null;
+    case "map":
+      return /* @__PURE__ */ new Map();
+    case "template-literal":
+      return "";
     case "any":
     case "unknown":
+    case "custom":
     case "void":
     case "never":
     case "promise":
-    case "custom":
-    case "template-literal":
-    case "transform":
-    case "map":
     case "symbol":
     case "function":
+    case "transform":
       return void 0;
     default:
       return ctx.unsupportedKindFallback(schema, kind);
   }
 }
 
-const store = /* @__PURE__ */ new WeakMap();
-const lists = /* @__PURE__ */ new WeakMap();
+const state = crossCopyState(/* @__PURE__ */ Symbol.for("attaform:field-meta-state"), () => ({
+  store: /* @__PURE__ */ new WeakMap(),
+  lists: /* @__PURE__ */ new WeakMap(),
+  pathMapBuilder: null
+}));
 const registry = {
   add(schema, payload) {
-    store.set(schema, payload);
-    const list = lists.get(schema) ?? [];
+    state.store.set(schema, payload);
+    const list = state.lists.get(schema) ?? [];
     list.push(payload);
-    lists.set(schema, list);
+    state.lists.set(schema, list);
     return registry;
   },
   get(schema) {
-    return store.get(schema);
+    return state.store.get(schema);
   },
   has(schema) {
-    return store.has(schema);
+    return state.store.has(schema);
   },
   remove(schema) {
-    store.delete(schema);
-    lists.delete(schema);
+    state.store.delete(schema);
+    state.lists.delete(schema);
     return registry;
   }
 };
 const fieldMetaStore = registry;
 function getFieldMetaForSchema(schema) {
-  return store.get(schema);
+  return state.store.get(schema);
 }
 function getFieldMetaListForSchema(schema) {
-  return lists.get(schema) ?? [];
+  return state.lists.get(schema) ?? [];
 }
-let pathMapBuilder = null;
 function installFieldMetaPathMapBuilder(builder) {
-  pathMapBuilder = builder;
+  state.pathMapBuilder = builder;
 }
 function buildFieldMetaPathMap(rootSchema, services) {
-  return pathMapBuilder === null ? void 0 : pathMapBuilder(rootSchema, services);
+  const builder = state.pathMapBuilder;
+  return builder === null ? void 0 : builder(rootSchema, services);
 }
 
 const PERMISSIVE_SLIM_KINDS = /* @__PURE__ */ new Set([
@@ -764,6 +837,16 @@ const KIND_UNDEFINED = /* @__PURE__ */ new Set(["undefined"]);
 const KIND_OBJECT = /* @__PURE__ */ new Set(["object"]);
 const KIND_ARRAY = /* @__PURE__ */ new Set(["array"]);
 const KIND_SET = /* @__PURE__ */ new Set(["set"]);
+const KIND_MAP = /* @__PURE__ */ new Set(["map"]);
+const KIND_SYMBOL = /* @__PURE__ */ new Set(["symbol", "undefined"]);
+const KIND_FUNCTION = /* @__PURE__ */ new Set([
+  "function",
+  "undefined"
+]);
+const KIND_PROMISE = /* @__PURE__ */ new Set([
+  "object",
+  "undefined"
+]);
 const KIND_FILE = /* @__PURE__ */ new Set(["file", "null"]);
 const EMPTY_KINDS = /* @__PURE__ */ new Set();
 function slimPrimitivesWalk(schema, intro, maxDepth, lazyDepth = 0) {
@@ -820,6 +903,16 @@ function slimPrimitivesWalk(schema, intro, maxDepth, lazyDepth = 0) {
       return KIND_ARRAY;
     case "set":
       return KIND_SET;
+    case "map":
+      return KIND_MAP;
+    case "symbol":
+      return KIND_SYMBOL;
+    case "function":
+      return KIND_FUNCTION;
+    case "promise":
+      return KIND_PROMISE;
+    case "template-literal":
+      return KIND_STRING;
     case "optional": {
       const inner = intro.unwrapInner(schema);
       const innerSet = inner === void 0 ? EMPTY_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
@@ -883,14 +976,19 @@ function slimPrimitivesWalk(schema, intro, maxDepth, lazyDepth = 0) {
     }
     case "never":
       return EMPTY_KINDS;
+    // Opaque leaves: the schema says nothing about the value's shape,
+    // so every kind is admissible. `custom` is the kind
+    // `z.instanceof(X)` and `z.custom<T>()` compile to on v4 (#542);
+    // it belongs with `any` / `unknown` rather than in the defensive
+    // fallthrough, because it reaches here through the public surface.
     case "any":
     case "unknown":
+    case "custom":
       return PERMISSIVE_SLIM_KINDS;
-    // Opaque / unsupported kinds: be permissive so legitimate writes
-    // aren't false-rejected. The unsupported kinds (`map` / `symbol` /
-    // `function` / `promise`) are rejected at adapter construction by
-    // `assertSupportedKinds`; this fallthrough keeps the walker
-    // defensive in case construction is skipped.
+    // A kind this walker has no case for — in practice a kind a newer
+    // Zod introduced. Be permissive rather than reject: the adapter
+    // carries the value opaquely and the schema's own parse is what
+    // decides whether it was legal.
     default:
       return PERMISSIVE_SLIM_KINDS;
   }
@@ -984,11 +1082,20 @@ function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress,
       case "set": {
         const inner = intro.getSetValueType(schema);
         if (inner !== void 0)
-          walkForMeta(inner, [...path, 0], map, counters, lastPathPerSchema, inProgress, services);
+          walkForMeta(
+            inner,
+            [...path, SET_MEMBER_SEGMENT],
+            map,
+            counters,
+            lastPathPerSchema,
+            inProgress,
+            services
+          );
         return;
       }
-      case "record": {
-        const inner = intro.getRecordValueType(schema);
+      case "record":
+      case "map": {
+        const inner = kind === "map" ? intro.getMapValueType(schema) : intro.getRecordValueType(schema);
         if (inner !== void 0)
           walkForMeta(inner, [...path, "*"], map, counters, lastPathPerSchema, inProgress, services);
         return;

package/dist/{shared/attaform.h0i6LijT.mjs → dev/shared/attaform-dev.ButTkwHd.mjs}

@@ -1,4 +1,4 @@
-import { f as pathsEqual, i as isPathPrefix } from './attaform.wfY8XFvm.mjs';
+import { m as mapSegmentKeys, f as pathsEqual, i as isPathPrefix } from './attaform-dev.A-TpJW0B.mjs';
 
 const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
 const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
@@ -10,6 +10,12 @@ 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) {
+    {
+      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)}.`
+      );
+    }
     return defaultValue;
   }
   return Math.max(min, Math.floor(value));
@@ -22,6 +28,60 @@ function pickDefined(bag) {
   return out;
 }
 
+const reported = /* @__PURE__ */ new Set() ;
+function report(site, err) {
+  if (reported === null || reported.has(site)) return;
+  reported.add(site);
+  const advice = site === "default-factory" ? "a `.default(() => ...)` factory threw. Attaform used `undefined` for that field's initial value." : site === "catch-factory" ? "a `.catch(() => ...)` fallback threw. Attaform used `undefined` for that value." : "a `z.lazy(() => ...)` factory threw. Attaform stopped descending at that node, so paths below it will not resolve.";
+  console.error(
+    `[attaform] ${advice} A function inside your schema must not throw; wrap your own try/catch if the failure is recoverable. Original error:`,
+    err
+  );
+}
+function callConsumerSchemaFn(fn, fallback, site) {
+  try {
+    return fn();
+  } catch (err) {
+    report(site, err);
+    return fallback;
+  }
+}
+function readConsumerProp(obj, key) {
+  try {
+    return obj[key];
+  } catch {
+    return void 0;
+  }
+}
+function consumerKeys(obj) {
+  try {
+    return Object.keys(obj);
+  } catch {
+    return [];
+  }
+}
+function readConsumerIndex(arr, i) {
+  try {
+    return arr[i];
+  } catch {
+    return void 0;
+  }
+}
+function consumerSymbolKeys(obj) {
+  try {
+    return Object.getOwnPropertySymbols(obj);
+  } catch {
+    return [];
+  }
+}
+function consumerHas(obj, key) {
+  try {
+    return key in obj;
+  } catch {
+    return false;
+  }
+}
+
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
     Object.defineProperty(target, key, {
@@ -41,17 +101,42 @@ function safeOwnRead(target, key) {
   if (isShadowedKey(key)) {
     const desc = Object.getOwnPropertyDescriptor(target, key);
     if (desc === void 0) return void 0;
-    return "value" in desc ? desc.value : target[key];
+    return "value" in desc ? desc.value : readConsumerProp(target, key);
   }
-  return target[key];
+  return readConsumerProp(target, key);
 }
 function safeOwnHas(target, key) {
-  return Object.prototype.hasOwnProperty.call(target, key);
+  try {
+    return Object.prototype.hasOwnProperty.call(target, key);
+  } catch {
+    return false;
+  }
+}
+function spreadConsumerRecord(src) {
+  try {
+    return { ...src };
+  } catch {
+    const out = {};
+    for (const key of Object.keys(src)) {
+      safeAssign(out, key, readConsumerProp(src, key));
+    }
+    return out;
+  }
+}
+function copyConsumerArray(src) {
+  try {
+    return src.slice();
+  } catch {
+    const out = new Array(src.length);
+    for (let i = 0; i < src.length; i++) out[i] = readConsumerIndex(src, i);
+    return out;
+  }
 }
 
 function isDescendable(value) {
   if (value === null || typeof value !== "object") return false;
   if (Array.isArray(value)) return true;
+  if (value instanceof Map) return mapSegmentKeys(value) !== null;
   const proto = Object.getPrototypeOf(value);
   return proto === null || proto === Object.prototype;
 }
@@ -77,6 +162,16 @@ function diffAndApply(oldValue, newValue, prefix, visit) {
     return;
   }
   if (oldIsDescendable && newIsDescendable) {
+    const oldIsMap = oldValue instanceof Map;
+    const newIsMap = newValue instanceof Map;
+    if (oldIsMap && newIsMap) {
+      diffMapsLockstep(oldValue, newValue, prefix, visit);
+      return;
+    }
+    if (oldIsMap !== newIsMap) {
+      visit({ kind: "changed", path: prefix, oldValue, newValue });
+      return;
+    }
     const oldIsArray = Array.isArray(oldValue);
     const newIsArray = Array.isArray(newValue);
     if (oldIsArray && newIsArray) {
@@ -116,46 +211,79 @@ function diffAndApply(oldValue, newValue, prefix, visit) {
 function walkNewDescendable(newValue, prefix, visit) {
   if (Array.isArray(newValue)) {
     for (let i = 0; i < newValue.length; i++) {
-      diffAndApply(void 0, newValue[i], appendSegment(prefix, i), visit);
+      diffAndApply(void 0, readConsumerIndex(newValue, i), appendSegment(prefix, i), visit);
+    }
+  } else if (newValue instanceof Map) {
+    for (const [key, entry] of newValue) {
+      diffAndApply(void 0, entry, appendSegment(prefix, key), visit);
     }
   } else {
     const rec = newValue;
-    for (const k of Object.keys(rec)) {
-      diffAndApply(void 0, rec[k], appendSegment(prefix, k), visit);
+    for (const k of consumerKeys(rec)) {
+      diffAndApply(void 0, readConsumerProp(rec, k), appendSegment(prefix, k), visit);
     }
   }
 }
 function walkOldDescendable(oldValue, prefix, visit) {
   if (Array.isArray(oldValue)) {
     for (let i = 0; i < oldValue.length; i++) {
-      diffAndApply(oldValue[i], void 0, appendSegment(prefix, i), visit);
+      diffAndApply(readConsumerIndex(oldValue, i), void 0, appendSegment(prefix, i), visit);
+    }
+  } else if (oldValue instanceof Map) {
+    for (const [key, entry] of oldValue) {
+      diffAndApply(entry, void 0, appendSegment(prefix, key), visit);
     }
   } else {
     const rec = oldValue;
-    for (const k of Object.keys(rec)) {
-      diffAndApply(rec[k], void 0, appendSegment(prefix, k), visit);
+    for (const k of consumerKeys(rec)) {
+      diffAndApply(readConsumerProp(rec, k), void 0, appendSegment(prefix, k), visit);
     }
   }
 }
+function diffMapsLockstep(oldMap, newMap, prefix, visit) {
+  for (const [key, entry] of newMap) {
+    diffAndApply(oldMap.get(key), entry, appendSegment(prefix, key), visit);
+  }
+  for (const [key, entry] of oldMap) {
+    if (newMap.has(key)) continue;
+    diffAndApply(entry, void 0, appendSegment(prefix, key), visit);
+  }
+}
 function diffArraysLockstep(oldArr, newArr, prefix, visit) {
   const max = Math.max(oldArr.length, newArr.length);
   for (let i = 0; i < max; i++) {
-    diffAndApply(oldArr[i], newArr[i], appendSegment(prefix, i), visit);
+    diffAndApply(
+      readConsumerIndex(oldArr, i),
+      readConsumerIndex(newArr, i),
+      appendSegment(prefix, i),
+      visit
+    );
   }
 }
 function diffObjectsLockstep(oldRec, newRec, prefix, visit) {
   const seen = /* @__PURE__ */ new Set();
-  for (const k of Object.keys(oldRec)) {
+  for (const k of consumerKeys(oldRec)) {
     seen.add(k);
-    diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+    diffAndApply(
+      readConsumerProp(oldRec, k),
+      readConsumerProp(newRec, k),
+      appendSegment(prefix, k),
+      visit
+    );
   }
-  for (const k of Object.keys(newRec)) {
+  for (const k of consumerKeys(newRec)) {
     if (seen.has(k)) continue;
-    diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+    diffAndApply(
+      readConsumerProp(oldRec, k),
+      readConsumerProp(newRec, k),
+      appendSegment(prefix, k),
+      visit
+    );
   }
 }
 function applyChangedKeys(target, source, arrayOpPath, currentPath, patches) {
   if (!isDescendable(target) || !isDescendable(source)) return false;
+  if (target instanceof Map || source instanceof Map) return false;
   const targetIsArray = Array.isArray(target);
   const sourceIsArray = Array.isArray(source);
   if (targetIsArray !== sourceIsArray) return false;
@@ -224,6 +352,11 @@ function applyChangedKeys(target, source, arrayOpPath, currentPath, patches) {
 }
 function structuralSnapshot(value) {
   if (!isDescendable(value)) return value;
+  if (value instanceof Map) {
+    const out2 = /* @__PURE__ */ new Map();
+    for (const [k, v] of value) out2.set(k, structuralSnapshot(v));
+    return out2;
+  }
   if (Array.isArray(value)) {
     const out2 = new Array(value.length);
     for (let i = 0; i < value.length; i++) {
@@ -239,4 +372,4 @@ function structuralSnapshot(value) {
   return out;
 }
 
-export { ANONYMOUS_FORM_KEY_PREFIX as A, DEFAULT_HISTORY_MAX_SNAPSHOTS as D, RESERVED_KEY_PREFIX as R, safeOwnRead as a, safeAssign as b, safeOwnHas as c, diffAndApply as d, DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS as e, applyChangedKeys as f, DEFAULT_MAX_RECURSION_DEPTH as g, ANONYMOUS_WIZARD_KEY_PREFIX as h, isShadowedKey as i, normalizeNumericOption as n, pickDefined as p, structuralSnapshot as s };
+export { ANONYMOUS_FORM_KEY_PREFIX as A, DEFAULT_HISTORY_MAX_SNAPSHOTS as D, RESERVED_KEY_PREFIX as R, safeOwnRead as a, safeAssign as b, callConsumerSchemaFn as c, consumerHas as d, safeOwnHas as e, spreadConsumerRecord as f, copyConsumerArray as g, consumerKeys as h, isShadowedKey as i, readConsumerProp as j, diffAndApply as k, DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS as l, consumerSymbolKeys as m, normalizeNumericOption as n, applyChangedKeys as o, pickDefined as p, DEFAULT_MAX_RECURSION_DEPTH as q, readConsumerIndex as r, structuralSnapshot as s, ANONYMOUS_WIZARD_KEY_PREFIX as t };

package/dist/{shared/attaform.BJGA_UOS.mjs → dev/shared/attaform-dev.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/dev/shared/{attaform-dev.P7cseiEG.mjs → attaform-dev.D8aoKb89.mjs}

@@ -1,5 +1,5 @@
 import { reactive, markRaw, isRef, effectScope, watch, warn, nextTick } from 'vue';
-import { e as canonicalizePath } from './attaform-dev.Dr2YzS5B.mjs';
+import { e as canonicalizePath } from './attaform-dev.A-TpJW0B.mjs';
 
 const INTERACTIVE_TAG_NAMES = /* @__PURE__ */ new Set(["INPUT", "SELECT", "TEXTAREA"]);
 
@@ -1143,6 +1143,14 @@ function setSelected(el, value) {
   const externalValue = value.innerRef.value;
   const isMultiple = el.multiple;
   const isArrayValue = isArray(externalValue);
+  const isUnset = externalValue === null || externalValue === void 0;
+  if (isMultiple && isUnset) {
+    for (let i = 0, l = el.options.length; i < l; i++) {
+      const option = el.options[i];
+      if (option !== void 0) option.selected = false;
+    }
+    return;
+  }
   if (isMultiple && !isArrayValue && !isSet(externalValue)) {
     {
       warn(
@@ -1180,10 +1188,11 @@ function setSelected(el, value) {
     }
     return;
   }
+  const target = value.displayValue.value === "" ? "" : externalValue;
   for (let i = 0, l = el.options.length; i < l; i++) {
     const option = el.options[i];
     if (!option) continue;
-    if (looseEqual(applyCoerce(getValue(option), value), externalValue)) {
+    if (looseEqual(applyCoerce(getValue(option), value), target)) {
       if (el.selectedIndex !== i) el.selectedIndex = i;
       return;
     }
@@ -1269,8 +1278,7 @@ function observeForLateHostControl(el, rv) {
   hostHealObservers.set(el, observer);
 }
 function activateComponentHost(el, rv) {
-  if (rv.hasRegisteredDescendant(el))
-    return;
+  if (rv.hasRegisteredDescendant(el)) return;
   el[REGISTER_OWNER_MARKER] = true;
   if (!el.tagName.includes("-")) {
     el.removeAttribute("registerValue");
@@ -1394,6 +1402,7 @@ function resolveDynamicModel(tagName, type) {
 function warnRedundantStateBinding(el, binding, vnode) {
   if (warnedRedundantBindings === null) return;
   if (!INTERACTIVE_TAG_NAMES.has(el.tagName)) return;
+  if (!isRegisterValue(binding.value)) return;
   if (binding.modifiers[V_REGISTER_COMPILED_MODIFIER] === true) return;
   const props = vnode.props;
   if (props == null) return;

package/dist/dev/shared/{attaform-dev.BXE2cr0L.mjs → attaform-dev.DD5m2W51.mjs}

@@ -1,4 +1,4 @@
-import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform-dev.Dr2YzS5B.mjs';
+import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform-dev.A-TpJW0B.mjs';
 import { shallowReactive, getCurrentInstance, inject } from 'vue';
 
 function detectSSR(options = {}) {