attaform 0.28.0 → 0.30.0

package/dist/shared/{attaform.C09fpdLS.mjs → attaform.CUfrMK7t.mjs}

@@ -1,16 +1,54 @@
-import { A as AttaformErrorCode, n as isPlainRecord, s as slimKindOf } from './attaform.B8k8JrmK.mjs';
-import { e as canonicalizePath } from './attaform.wfY8XFvm.mjs';
-import { a as safeOwnRead, b as safeAssign } from './attaform.h0i6LijT.mjs';
+import { A as AttaformErrorCode, k as isPlainRecord, s as slimKindOf } from './attaform.DNJOWjQw.mjs';
+import { e as canonicalizePath, h as SET_MEMBER_SEGMENT } from './attaform.CdZIEf7_.mjs';
+import { a as safeOwnRead, b as safeAssign } from './attaform.BRDDQeHV.mjs';
 
 const PATH_SEPARATOR = ".";
-function createAbstractSchema(rootSchema, intro, services, formKey, options) {
+function isOpaqueKind(kind) {
+  return kind === "any" || kind === "unknown" || kind === "custom";
+}
+const MEMO_CAP = 4096;
+const ROOT_KINDS = /* @__PURE__ */ new Set(["object"]);
+const NO_KINDS = /* @__PURE__ */ new Set();
+function memoPut(memo, key, value) {
+  if (memo.size >= MEMO_CAP) memo.clear();
+  memo.set(key, value);
+  return value;
+}
+function createSharedSchemaStore() {
+  const bySchema = /* @__PURE__ */ new WeakMap();
+  return (rootSchema, maxRecursionDepth, build) => {
+    let byDepth = bySchema.get(rootSchema);
+    if (byDepth === void 0) {
+      byDepth = /* @__PURE__ */ new Map();
+      bySchema.set(rootSchema, byDepth);
+    }
+    const hit = byDepth.get(maxRecursionDepth);
+    if (hit !== void 0) return hit;
+    const built = build();
+    byDepth.set(maxRecursionDepth, built);
+    return built;
+  };
+}
+function createAbstractSchema(rootSchema, intro, services, 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();
+  const slimKindsCache = /* @__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;
@@ -42,7 +80,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
           if (intro.kindOf(litSchema) !== "literal") continue;
           const literalValues = intro.getLiteralValues(litSchema);
           if (literalValues.includes(value)) {
-            return services.deriveDefault(opt, true, maxRecursionDepth, formKey);
+            return services.deriveDefault(opt, true, maxRecursionDepth);
           }
         }
         return void 0;
@@ -53,7 +91,6 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
     };
   }
   const abstractSchema = {
-    fingerprint: () => services.fingerprint(rootSchema),
     needsAsyncValidation() {
       asyncValidationFlag ?? (asyncValidationFlag = intro.containsAsyncRefine(rootSchema) || intro.containsAsyncTransform(rootSchema));
       return asyncValidationFlag;
@@ -67,24 +104,24 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       return discriminatedUnionFlag;
     },
     getDefaultValues(config) {
-      return services.runStrictGetDefaults(rootSchema, config, formKey, maxRecursionDepth);
+      return services.runGetDefaults(rootSchema, config, maxRecursionDepth);
     },
     getDefaultAtPath(path) {
       if (path.length === 0) {
-        return services.deriveDefault(rootSchema, true, maxRecursionDepth, formKey);
+        return services.deriveDefault(rootSchema, true, maxRecursionDepth);
       }
       const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
       if (first === void 0) return void 0;
       const peeled = services.unwrapStructuralWrappers(first);
-      return services.deriveDefault(peeled, true, maxRecursionDepth, formKey);
+      return services.deriveDefault(peeled, true, maxRecursionDepth);
     },
     getEmptyValueAtPath(path) {
       if (path.length === 0) {
-        return services.deriveDefault(rootSchema, false, maxRecursionDepth, formKey);
+        return services.deriveDefault(rootSchema, false, maxRecursionDepth);
       }
       const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
       if (first === void 0) return void 0;
-      return services.deriveDefault(first, false, maxRecursionDepth, formKey);
+      return services.deriveDefault(first, false, maxRecursionDepth);
     },
     arrayShapeAtPath(path) {
       if (path.length === 0) return null;
@@ -102,31 +139,59 @@ 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;
+        }
+      }
+      return memoPut(entryKeyKindCache, cacheKey, answer);
+    },
     getSchemasAtPath(path) {
       const resolved = services.getNestedSchemasInSlimMode(rootSchema, path, maxRecursionDepth);
       if (resolved.length === 0) return [];
-      return resolved.map((sub) => services.makeSubSchema(sub, formKey, maxRecursionDepth));
+      return resolved.map((sub) => services.makeSubSchema(sub, maxRecursionDepth));
     },
     getSlimPrimitiveTypesAtPath(path) {
-      if (path.length === 0) return /* @__PURE__ */ new Set(["object"]);
+      if (path.length === 0) return ROOT_KINDS;
+      const cacheKey = canonicalizePath(path).key;
+      const hit = slimKindsCache.get(cacheKey);
+      if (hit !== void 0) return hit;
       const resolved = services.getNestedSchemasInSlimMode(rootSchema, path, maxRecursionDepth);
-      if (resolved.length === 0) return /* @__PURE__ */ new Set();
+      if (resolved.length === 0) return memoPut(slimKindsCache, cacheKey, NO_KINDS);
       const out = /* @__PURE__ */ new Set();
       for (const candidate of resolved) {
         for (const k of services.slimPrimitivesOf(candidate, maxRecursionDepth)) {
           out.add(k);
         }
       }
-      return out;
+      return memoPut(slimKindsCache, cacheKey, out);
     },
     isLeafAtPath(path) {
       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");
-      leafCache.set(cacheKey, isLeaf);
-      return isLeaf;
+      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");
+      return memoPut(leafCache, cacheKey, isLeaf);
     },
     isPreprocessOrCoerceLeaf(path) {
       const cacheKey = canonicalizePath(path).key;
@@ -143,8 +208,17 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
           }
         }
       }
-      preprocessOrCoerceCache.set(cacheKey, hit);
-      return hit;
+      return memoPut(preprocessOrCoerceCache, cacheKey, 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)))
+      );
+      return memoPut(opaqueLeafCache, cacheKey, opaque);
     },
     isRequiredAtPath(path) {
       if (path.length === 0) return true;
@@ -160,9 +234,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       if (discriminatorCache.has(cacheKey)) {
         return discriminatorCache.get(cacheKey);
       }
-      const result = computeDiscriminator(path);
-      discriminatorCache.set(cacheKey, result);
-      return result;
+      return memoPut(discriminatorCache, cacheKey, computeDiscriminator(path));
     },
     validateAtPath(data, path, validateOptions) {
       const trySync = validateOptions?.sync === true;
@@ -174,11 +246,10 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       }
       return runAsync();
       function parseResultToResponse(result) {
-        return result.success ? { data: result.data, errors: void 0, success: true, formKey } : {
+        return result.success ? { data: result.data, errors: void 0, success: true } : {
           data: void 0,
           errors: services.issuesToValidationErrors(result.issues),
-          success: false,
-          formKey
+          success: false
         };
       }
       function runSync() {
@@ -193,7 +264,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
           if (response.success) return response;
           aggregated.push(...response.errors);
         }
-        return { data: void 0, errors: aggregated, success: false, formKey };
+        return { data: void 0, errors: aggregated, success: false };
       }
       async function runAsync() {
         if (path === void 0) {
@@ -219,7 +290,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
           if (response.success) return response;
           aggregated.push(...response.errors);
         }
-        return { data: void 0, errors: aggregated, success: false, formKey };
+        return { data: void 0, errors: aggregated, success: false };
       }
       function validatorThrewResponse(err, errPath) {
         const message = err instanceof Error ? err.message : typeof err === "string" ? err : "Validator threw";
@@ -232,8 +303,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
               code: AttaformErrorCode.ValidatorThrew
             }
           ],
-          success: false,
-          formKey
+          success: false
         };
       }
       function pathNotFound(p) {
@@ -246,8 +316,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
               code: AttaformErrorCode.PathNotFound
             }
           ],
-          success: false,
-          formKey
+          success: false
         };
       }
     }
@@ -289,6 +358,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 +366,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 [];
@@ -316,6 +390,8 @@ function walkPathSegments(schema, segments, intro, maxDepth, lazyDepth) {
     case "optional":
     case "nullable":
     case "default":
+    case "nonoptional":
+    case "success":
     case "readonly":
     case "catch": {
       const inner = intro.unwrapInner(schema);
@@ -349,11 +425,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 [];
   }
@@ -387,6 +465,8 @@ function fixNode(schema, value, ctx, lazyDepth) {
       return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth);
     }
     case "default":
+    case "nonoptional":
+    case "success":
     case "readonly":
     case "catch": {
       const inner = intro.unwrapInner(schema);
@@ -461,6 +541,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);
@@ -543,7 +632,7 @@ function hasDeclaredDefaultInChain(schema, intro) {
   }
   return false;
 }
-function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth = 0) {
+function deriveDefaultWalk(schema, useDefault, intro, maxDepth, lazyDepth = 0) {
   if (useDefault) {
     const peeled = peelEmbeddedDefault(schema, intro);
     if (peeled !== NO_EMBEDDED_DEFAULT) return peeled;
@@ -555,11 +644,7 @@ function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth =
       const shape = intro.getObjectShape(schema);
       const out = {};
       for (const [key, subSchema] of Object.entries(shape)) {
-        safeAssign(
-          out,
-          key,
-          deriveDefaultWalk(subSchema, useDefault, intro, maxDepth, ctx, lazyDepth)
-        );
+        safeAssign(out, key, deriveDefaultWalk(subSchema, useDefault, intro, maxDepth, lazyDepth));
       }
       return out;
     }
@@ -571,19 +656,17 @@ function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth =
       return {};
     case "tuple": {
       const items = intro.getTupleItems(schema);
-      return items.map(
-        (item) => deriveDefaultWalk(item, useDefault, intro, maxDepth, ctx, lazyDepth)
-      );
+      return items.map((item) => deriveDefaultWalk(item, useDefault, intro, maxDepth, lazyDepth));
     }
     case "union": {
       const options = intro.getUnionOptions(schema);
       const first = options[0];
-      return first === void 0 ? void 0 : deriveDefaultWalk(first, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return first === void 0 ? void 0 : deriveDefaultWalk(first, useDefault, intro, maxDepth, lazyDepth);
     }
     case "discriminated-union": {
       const options = intro.getDiscriminatedOptions(schema);
       const first = options[0];
-      return first === void 0 ? void 0 : deriveDefaultWalk(first, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return first === void 0 ? void 0 : deriveDefaultWalk(first, useDefault, intro, maxDepth, lazyDepth);
     }
     case "optional":
       return void 0;
@@ -592,39 +675,41 @@ function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth =
     case "default": {
       if (useDefault) return intro.getDefaultValue(schema);
       const inner = intro.unwrapInner(schema);
-      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, lazyDepth);
     }
+    case "nonoptional":
+    case "success":
     case "readonly":
     case "branded": {
       const inner = kind === "branded" ? intro.unwrapBranded(schema) : intro.unwrapInner(schema);
-      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, lazyDepth);
     }
     case "effects": {
       const inner = intro.unwrapEffectsSource(schema);
       if (intro.isPreprocessNode(schema)) {
         if (inner !== void 0 && hasDeclaredDefaultInChain(inner, intro)) {
-          return deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
+          return deriveDefaultWalk(inner, useDefault, intro, maxDepth, lazyDepth);
         }
         return void 0;
       }
-      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, lazyDepth);
     }
     case "pipeline": {
       const inner = intro.unwrapPipeIn(schema);
-      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, lazyDepth);
     }
     case "pipe": {
       const inn = intro.unwrapPipeIn(schema);
       if (inn !== void 0 && intro.kindOf(inn) === "transform") {
         const out2 = intro.unwrapPipeOut(schema);
         if (out2 !== void 0 && hasDeclaredDefaultInChain(out2, intro)) {
-          return deriveDefaultWalk(out2, useDefault, intro, maxDepth, ctx, lazyDepth);
+          return deriveDefaultWalk(out2, useDefault, intro, maxDepth, lazyDepth);
         }
         return void 0;
       }
       const out = intro.unwrapPipeOut(schema);
       const real = inn !== void 0 && intro.kindOf(inn) !== "transform" ? inn : out !== void 0 && intro.kindOf(out) !== "transform" ? out : inn ?? out;
-      return real === void 0 ? void 0 : deriveDefaultWalk(real, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return real === void 0 ? void 0 : deriveDefaultWalk(real, useDefault, intro, maxDepth, lazyDepth);
     }
     case "string":
       return "";
@@ -668,74 +753,84 @@ function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth =
       } catch {
         return void 0;
       }
-      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth + 1);
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, lazyDepth + 1);
     }
     case "intersection": {
       const left = intro.getIntersectionLeft(schema);
       const right = intro.getIntersectionRight(schema);
-      const l = left === void 0 ? void 0 : deriveDefaultWalk(left, useDefault, intro, maxDepth, ctx, lazyDepth);
-      const r = right === void 0 ? void 0 : deriveDefaultWalk(right, useDefault, intro, maxDepth, ctx, lazyDepth);
+      const l = left === void 0 ? void 0 : deriveDefaultWalk(left, useDefault, intro, maxDepth, lazyDepth);
+      const r = right === void 0 ? void 0 : deriveDefaultWalk(right, useDefault, intro, maxDepth, lazyDepth);
       return mergeDeep(l, r);
     }
     case "catch": {
       if (useDefault) return intro.getCatchDefault(schema);
       const inner = intro.unwrapInner(schema);
-      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, 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);
+      return void 0;
   }
 }
 
-const store = /* @__PURE__ */ new WeakMap();
-const lists = /* @__PURE__ */ new WeakMap();
+function crossCopyState(key, create) {
+  const carrier = globalThis;
+  return carrier[key] ?? (carrier[key] = create());
+}
+
+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 +859,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 +925,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);
@@ -836,10 +951,20 @@ function slimPrimitivesWalk(schema, intro, maxDepth, lazyDepth = 0) {
     }
     case "default":
     case "readonly":
+    case "success":
     case "catch": {
       const inner = intro.unwrapInner(schema);
       return inner === void 0 ? PERMISSIVE_SLIM_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
     }
+    case "nonoptional": {
+      const inner = intro.unwrapInner(schema);
+      if (inner === void 0) return PERMISSIVE_SLIM_KINDS;
+      const innerSet = slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
+      if (!innerSet.has("undefined")) return innerSet;
+      const out = new Set(innerSet);
+      out.delete("undefined");
+      return out;
+    }
     case "branded": {
       const inner = intro.unwrapBranded(schema);
       return inner === void 0 ? PERMISSIVE_SLIM_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
@@ -883,14 +1008,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 +1114,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;
@@ -1060,4 +1199,4 @@ function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress,
   }
 }
 
-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 };
+export { createSharedSchemaStore as a, buildFieldMetaPathMap as b, createAbstractSchema as c, deriveDefaultWalk as d, getFieldMetaListForSchema as e, fixStructuralDefaults as f, getFieldMetaForSchema as g, installingFieldMetaStore as i, mergeDeep as m, slimPrimitivesWalk as s, walkPathSegments as w };