attaform 0.27.6 → 0.29.0

package/dist/{shared/attaform.D6tk90Rc.cjs → dev/shared/attaform-dev.BgM6FdtA.mjs}

@@ -1,16 +1,30 @@
-'use strict';
-
-const serializeScript = require('./attaform.DrvMscNX.cjs');
-const devtoolsShared = require('./attaform.Biytrv0-.cjs');
+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;
@@ -62,6 +76,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 +101,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) {
@@ -100,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 [];
@@ -118,16 +160,17 @@ 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);
-      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;
     },
     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;
@@ -144,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);
@@ -154,7 +208,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 +228,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 +281,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
             {
               message,
               path: [...errPath],
-              formKey,
-              code: serializeScript.AttaformErrorCode.ValidatorThrew
+              code: AttaformErrorCode.ValidatorThrew
             }
           ],
           success: false,
@@ -242,8 +295,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 +309,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;
@@ -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,16 +406,165 @@ 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 [];
   }
 }
 
+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 "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);
+      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 +623,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,59 +747,68 @@ 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);
     }
     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) ?? [];
+}
+function installFieldMetaPathMapBuilder(builder) {
+  state.pathMapBuilder = builder;
+}
+function buildFieldMetaPathMap(rootSchema, services) {
+  const builder = state.pathMapBuilder;
+  return builder === null ? void 0 : builder(rootSchema, services);
 }
 
 const PERMISSIVE_SLIM_KINDS = /* @__PURE__ */ new Set([
@@ -622,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) {
@@ -667,7 +892,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":
@@ -678,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);
@@ -741,19 +976,37 @@ 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;
   }
 }
 
+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 +1040,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) {
@@ -829,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;
@@ -905,15 +1167,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.D6tk90Rc.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 };