attaform 0.19.0 → 0.20.1

package/dist/shared/attaform.tVkmQh5w.mjs

@@ -0,0 +1,774 @@
+import { A as AttaformErrorCode, e as isPlainRecord, j as safeOwnRead, s as safeAssign, m as slimKindOf } from './attaform.BqZuwLTK.mjs';
+import { j as canonicalizePath } from './attaform.BKozEdTr.mjs';
+
+const PATH_SEPARATOR = ".";
+function createAbstractSchema(rootSchema, intro, services, formKey, options) {
+  const maxRecursionDepth = options.maxRecursionDepth;
+  const leafCache = /* @__PURE__ */ new Map();
+  const preprocessOrCoerceCache = /* @__PURE__ */ new Map();
+  const discriminatorCache = /* @__PURE__ */ new Map();
+  let asyncValidationFlag = null;
+  let containerRefineFlag = null;
+  function computeDiscriminator(path) {
+    const candidates = path.length === 0 ? [rootSchema] : services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
+    let matchedUnion;
+    for (const candidate of candidates) {
+      const du = services.unwrapToDiscriminatedUnion(candidate);
+      if (du === void 0) continue;
+      if (matchedUnion !== void 0 && matchedUnion !== du) return void 0;
+      matchedUnion = du;
+    }
+    if (matchedUnion === void 0) return void 0;
+    const discKey = intro.getDiscriminator(matchedUnion);
+    if (discKey === void 0) return void 0;
+    const unionOptions = intro.getDiscriminatedOptions(matchedUnion);
+    const literalSet = /* @__PURE__ */ new Set();
+    for (const opt of unionOptions) {
+      const shape = intro.getObjectShape(opt);
+      const litSchema = shape[discKey];
+      if (litSchema === void 0) continue;
+      if (intro.kindOf(litSchema) !== "literal") continue;
+      for (const v of intro.getLiteralValues(litSchema)) literalSet.add(v);
+    }
+    return {
+      discriminatorKey: discKey,
+      getVariantDefault(value) {
+        for (const opt of unionOptions) {
+          const shape = intro.getObjectShape(opt);
+          const litSchema = shape[discKey];
+          if (litSchema === void 0) continue;
+          if (intro.kindOf(litSchema) !== "literal") continue;
+          const literalValues = intro.getLiteralValues(litSchema);
+          if (literalValues.includes(value)) {
+            return services.deriveDefault(opt, true, maxRecursionDepth, formKey);
+          }
+        }
+        return void 0;
+      },
+      isVariantSelected(value) {
+        return literalSet.has(value);
+      }
+    };
+  }
+  const abstractSchema = {
+    fingerprint: () => services.fingerprint(rootSchema),
+    needsAsyncValidation() {
+      asyncValidationFlag ?? (asyncValidationFlag = intro.containsAsyncRefine(rootSchema) || intro.containsAsyncTransform(rootSchema));
+      return asyncValidationFlag;
+    },
+    hasContainerOrRootRefine() {
+      containerRefineFlag ?? (containerRefineFlag = intro.hasContainerOrRootRefine(rootSchema));
+      return containerRefineFlag;
+    },
+    getDefaultValues(config) {
+      return services.runStrictGetDefaults(rootSchema, config, formKey, maxRecursionDepth);
+    },
+    getDefaultAtPath(path) {
+      if (path.length === 0) {
+        return services.deriveDefault(rootSchema, true, maxRecursionDepth, formKey);
+      }
+      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);
+    },
+    getEmptyValueAtPath(path) {
+      if (path.length === 0) {
+        return services.deriveDefault(rootSchema, false, maxRecursionDepth, formKey);
+      }
+      const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
+      if (first === void 0) return void 0;
+      return services.deriveDefault(first, false, maxRecursionDepth, formKey);
+    },
+    arrayShapeAtPath(path) {
+      if (path.length === 0) return void 0;
+      const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
+      if (first === void 0) return void 0;
+      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;
+    },
+    getSchemasAtPath(path) {
+      const resolved = services.getNestedSchemasInSlimMode(rootSchema, path, maxRecursionDepth);
+      if (resolved.length === 0) return [];
+      return resolved.map((sub) => services.makeSubSchema(sub, formKey, maxRecursionDepth));
+    },
+    getSlimPrimitiveTypesAtPath(path) {
+      if (path.length === 0) return /* @__PURE__ */ new Set(["object"]);
+      const resolved = services.getNestedSchemasInSlimMode(rootSchema, path, maxRecursionDepth);
+      if (resolved.length === 0) return /* @__PURE__ */ new Set();
+      const out = /* @__PURE__ */ new Set();
+      for (const candidate of resolved) {
+        for (const k of services.slimPrimitivesOf(candidate, maxRecursionDepth)) {
+          out.add(k);
+        }
+      }
+      return 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;
+    },
+    isPreprocessOrCoerceLeaf(path) {
+      const cacheKey = canonicalizePath(path).key;
+      const cached = preprocessOrCoerceCache.get(cacheKey);
+      if (cached !== void 0) return cached;
+      let hit = false;
+      for (let i = 0; i <= path.length && !hit; i++) {
+        const prefix = path.slice(0, i);
+        const candidates = prefix.length === 0 ? [rootSchema] : services.getNestedSchemasAtPath(rootSchema, prefix, maxRecursionDepth);
+        for (const candidate of candidates) {
+          if (intro.isCoercePrimitive(candidate) || intro.isPreprocessNode(candidate)) {
+            hit = true;
+            break;
+          }
+        }
+      }
+      preprocessOrCoerceCache.set(cacheKey, hit);
+      return hit;
+    },
+    isRequiredAtPath(path) {
+      if (path.length === 0) return true;
+      const resolved = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
+      if (resolved.length === 0) return false;
+      return resolved.every((candidate) => services.isLeafRequired(candidate));
+    },
+    getFieldMetaAtPath(path) {
+      return services.resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth);
+    },
+    getUnionDiscriminatorAtPath(path) {
+      const cacheKey = canonicalizePath(path).key;
+      if (discriminatorCache.has(cacheKey)) {
+        return discriminatorCache.get(cacheKey);
+      }
+      const result = computeDiscriminator(path);
+      discriminatorCache.set(cacheKey, result);
+      return result;
+    },
+    validateAtPath(data, path, validateOptions) {
+      const trySync = validateOptions?.sync === true;
+      if (trySync) {
+        try {
+          return runSync();
+        } catch {
+        }
+      }
+      return runAsync();
+      function runSync() {
+        if (path === void 0) {
+          const result = services.safeParseSync(rootSchema, data);
+          return result.success ? {
+            data: result.data,
+            errors: void 0,
+            success: true,
+            formKey
+          } : {
+            data: void 0,
+            errors: services.issuesToValidationErrors(result.issues, formKey),
+            success: false,
+            formKey
+          };
+        }
+        const resolved = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
+        if (resolved.length === 0) return pathNotFound(path);
+        const aggregated = [];
+        for (const candidate of resolved) {
+          const result = services.safeParseSync(candidate, data);
+          if (result.success) {
+            return {
+              data: result.data,
+              errors: void 0,
+              success: true,
+              formKey
+            };
+          }
+          aggregated.push(...services.issuesToValidationErrors(result.issues, formKey));
+        }
+        return { data: void 0, errors: aggregated, success: false, formKey };
+      }
+      async function runAsync() {
+        if (path === void 0) {
+          let result;
+          try {
+            result = await services.safeParseAsync(rootSchema, data);
+          } catch (err) {
+            return validatorThrewResponse(err, []);
+          }
+          return result.success ? {
+            data: result.data,
+            errors: void 0,
+            success: true,
+            formKey
+          } : {
+            data: void 0,
+            errors: services.issuesToValidationErrors(result.issues, formKey),
+            success: false,
+            formKey
+          };
+        }
+        const resolved = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
+        if (resolved.length === 0) return pathNotFound(path);
+        const aggregated = [];
+        for (const candidate of resolved) {
+          let result;
+          try {
+            result = await services.safeParseAsync(candidate, data);
+          } catch (err) {
+            return validatorThrewResponse(err, path);
+          }
+          if (result.success) {
+            return {
+              data: result.data,
+              errors: void 0,
+              success: true,
+              formKey
+            };
+          }
+          aggregated.push(...services.issuesToValidationErrors(result.issues, formKey));
+        }
+        return { data: void 0, errors: aggregated, success: false, formKey };
+      }
+      function validatorThrewResponse(err, errPath) {
+        const message = err instanceof Error ? err.message : typeof err === "string" ? err : "Validator threw";
+        return {
+          data: void 0,
+          errors: [
+            {
+              message,
+              path: [...errPath],
+              formKey,
+              code: AttaformErrorCode.ValidatorThrew
+            }
+          ],
+          success: false,
+          formKey
+        };
+      }
+      function pathNotFound(p) {
+        return {
+          data: void 0,
+          errors: [
+            {
+              message: `Path '${p.join(PATH_SEPARATOR)}' did not resolve to any schema`,
+              path: [...p],
+              formKey,
+              code: AttaformErrorCode.PathNotFound
+            }
+          ],
+          success: false,
+          formKey
+        };
+      }
+    }
+  };
+  return abstractSchema;
+}
+
+function walkPathSegments(schema, segments, intro, maxDepth, lazyDepth) {
+  if (segments.length === 0) return [schema];
+  const [head, ...rest] = segments;
+  if (head === void 0) return [schema];
+  const kind = intro.kindOf(schema);
+  switch (kind) {
+    case "object": {
+      const shape = intro.getObjectShape(schema);
+      if (!Object.hasOwn(shape, head)) return [];
+      const next = shape[head];
+      return next === void 0 ? [] : walkPathSegments(next, rest, intro, maxDepth, lazyDepth);
+    }
+    case "array": {
+      const inner = intro.getArrayElement(schema);
+      return inner === void 0 ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth);
+    }
+    case "set": {
+      const inner = intro.getSetValueType(schema);
+      return inner === void 0 ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth);
+    }
+    case "record": {
+      const inner = intro.getRecordValueType(schema);
+      return inner === void 0 ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth);
+    }
+    case "tuple": {
+      const index = Number(head);
+      if (!Number.isInteger(index)) return [];
+      const items = intro.getTupleItems(schema);
+      const item = items[index];
+      return item === void 0 ? [] : walkPathSegments(item, rest, intro, maxDepth, lazyDepth);
+    }
+    case "union":
+      return intro.getUnionOptions(schema).flatMap((opt) => walkPathSegments(opt, segments, intro, maxDepth, lazyDepth));
+    case "discriminated-union": {
+      const options = intro.getDiscriminatedOptions(schema);
+      const matching = options.filter((opt) => Object.hasOwn(intro.getObjectShape(opt), head));
+      const candidates = matching.length > 0 ? matching : options;
+      return candidates.flatMap(
+        (opt) => walkPathSegments(opt, segments, intro, maxDepth, lazyDepth)
+      );
+    }
+    case "optional":
+    case "nullable":
+    case "default":
+    case "readonly":
+    case "catch": {
+      const inner = intro.unwrapInner(schema);
+      return inner === void 0 ? [] : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth);
+    }
+    case "pipe": {
+      const inner = intro.unwrapPipeIn(schema) ?? intro.unwrapPipeOut(schema);
+      return inner === void 0 ? [] : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth);
+    }
+    case "pipeline": {
+      const inner = intro.unwrapPipeIn(schema);
+      return inner === void 0 ? [] : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth);
+    }
+    case "effects": {
+      const inner = intro.unwrapEffectsSource(schema);
+      return inner === void 0 ? [] : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth);
+    }
+    case "branded": {
+      const inner = intro.unwrapBranded(schema);
+      return inner === void 0 ? [] : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth);
+    }
+    case "lazy": {
+      if (lazyDepth >= maxDepth) return [];
+      const inner = intro.unwrapLazy(schema);
+      return inner === void 0 ? [] : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth + 1);
+    }
+    case "intersection": {
+      const left = intro.getIntersectionLeft(schema);
+      const right = intro.getIntersectionRight(schema);
+      const leftResults = left === void 0 ? [] : walkPathSegments(left, 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).
+    default:
+      return [];
+  }
+}
+
+function mergeDeep(base, override) {
+  if (override === void 0) return base;
+  if (!isPlainRecord(override)) return override;
+  if (!isPlainRecord(base)) return override;
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const oVal = safeOwnRead(override, key);
+    const bVal = safeOwnRead(base, key);
+    if (isPlainRecord(oVal) && isPlainRecord(bVal)) {
+      safeAssign(result, key, mergeDeep(bVal, oVal));
+    } else {
+      safeAssign(result, key, oVal);
+    }
+  }
+  return result;
+}
+
+const NO_EMBEDDED_DEFAULT = Symbol("atta:no-embedded-default");
+function peelEmbeddedDefault(schema, intro) {
+  let current = schema;
+  for (let i = 0; i < 32; i++) {
+    if (current === void 0) return NO_EMBEDDED_DEFAULT;
+    const k = intro.kindOf(current);
+    if (k === "default") return intro.getDefaultValue(current);
+    if (k === "catch") {
+      if (intro.hasCatchValue(current)) return intro.getCatchDefault(current);
+      current = intro.unwrapInner(current);
+      continue;
+    }
+    if (k === "optional" || k === "nullable" || k === "readonly") {
+      current = intro.unwrapInner(current);
+      continue;
+    }
+    if (k === "branded") {
+      current = intro.unwrapBranded(current);
+      continue;
+    }
+    if (k === "effects") {
+      current = intro.unwrapEffectsSource(current);
+      continue;
+    }
+    if (k === "pipeline") {
+      current = intro.unwrapPipeIn(current);
+      continue;
+    }
+    return NO_EMBEDDED_DEFAULT;
+  }
+  return NO_EMBEDDED_DEFAULT;
+}
+function hasDeclaredDefaultInChain(schema, intro) {
+  let current = schema;
+  for (let i = 0; i < 32; i++) {
+    if (current === void 0) return false;
+    const k = intro.kindOf(current);
+    if (k === "default") return true;
+    if (k === "optional" || k === "nullable" || k === "readonly" || k === "catch") {
+      current = intro.unwrapInner(current);
+      continue;
+    }
+    return false;
+  }
+  return false;
+}
+function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth = 0) {
+  if (useDefault) {
+    const peeled = peelEmbeddedDefault(schema, intro);
+    if (peeled !== NO_EMBEDDED_DEFAULT) return peeled;
+  }
+  if (intro.isCoercePrimitive(schema)) return void 0;
+  const kind = intro.kindOf(schema);
+  switch (kind) {
+    case "object": {
+      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)
+        );
+      }
+      return out;
+    }
+    case "array":
+      return [];
+    case "set":
+      return /* @__PURE__ */ new Set();
+    case "record":
+      return {};
+    case "tuple": {
+      const items = intro.getTupleItems(schema);
+      return items.map(
+        (item) => deriveDefaultWalk(item, useDefault, intro, maxDepth, ctx, 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);
+    }
+    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);
+    }
+    case "optional":
+      return void 0;
+    case "nullable":
+      return null;
+    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);
+    }
+    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);
+    }
+    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 void 0;
+      }
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
+    }
+    case "pipeline": {
+      const inner = intro.unwrapPipeIn(schema);
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, 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 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);
+    }
+    case "string":
+      return "";
+    case "number":
+      return 0;
+    case "bigint":
+      return 0n;
+    case "boolean":
+      return false;
+    case "date":
+      return /* @__PURE__ */ new Date(0);
+    case "null":
+      return null;
+    case "undefined":
+      return void 0;
+    case "enum": {
+      const values = intro.getEnumValues(schema);
+      return values[0];
+    }
+    case "native-enum": {
+      const values = intro.getNativeEnumValues(schema);
+      if (values === void 0) return void 0;
+      const validKeys = Object.keys(values).filter(
+        (k) => typeof values[values[k]] !== "number"
+      );
+      if (validKeys.length === 0) return void 0;
+      const first = validKeys[0];
+      return first === void 0 ? void 0 : values[first];
+    }
+    case "literal": {
+      const values = intro.getLiteralValues(schema);
+      return values[0];
+    }
+    case "nan":
+      return NaN;
+    case "lazy": {
+      if (lazyDepth >= maxDepth) return void 0;
+      let inner;
+      try {
+        inner = intro.unwrapLazy(schema);
+      } catch {
+        return void 0;
+      }
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, 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);
+      return mergeDeep(l, r);
+    }
+    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 "any":
+    case "unknown":
+    case "void":
+    case "never":
+    case "promise":
+    case "custom":
+    case "template-literal":
+    case "transform":
+    case "map":
+    case "symbol":
+    case "function":
+      return void 0;
+    default:
+      return ctx.unsupportedKindFallback(schema, kind);
+  }
+}
+
+const store = /* @__PURE__ */ new WeakMap();
+const lists = /* @__PURE__ */ new WeakMap();
+const registry = {
+  add(schema, payload) {
+    store.set(schema, payload);
+    const list = lists.get(schema) ?? [];
+    list.push(payload);
+    lists.set(schema, list);
+    return registry;
+  },
+  get(schema) {
+    return store.get(schema);
+  },
+  has(schema) {
+    return store.has(schema);
+  },
+  remove(schema) {
+    store.delete(schema);
+    lists.delete(schema);
+    return registry;
+  }
+};
+const fieldMetaStore = registry;
+function getFieldMetaForSchema(schema) {
+  return store.get(schema);
+}
+function getFieldMetaListForSchema(schema) {
+  return lists.get(schema) ?? [];
+}
+
+const PERMISSIVE_SLIM_KINDS = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "bigint",
+  "date",
+  "null",
+  "undefined",
+  "object",
+  "array",
+  "symbol",
+  "function",
+  "map",
+  "set",
+  "file"
+]);
+const KIND_STRING = /* @__PURE__ */ new Set(["string"]);
+const KIND_NUMBER = /* @__PURE__ */ new Set(["number"]);
+const KIND_BOOLEAN = /* @__PURE__ */ new Set(["boolean"]);
+const KIND_BIGINT = /* @__PURE__ */ new Set(["bigint"]);
+const KIND_DATE = /* @__PURE__ */ new Set(["date"]);
+const KIND_NULL = /* @__PURE__ */ new Set(["null"]);
+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_FILE = /* @__PURE__ */ new Set(["file", "null"]);
+const EMPTY_KINDS = /* @__PURE__ */ new Set();
+function slimPrimitivesWalk(schema, intro, maxDepth, lazyDepth = 0) {
+  const kind = intro.kindOf(schema);
+  switch (kind) {
+    case "string":
+      return KIND_STRING;
+    case "number":
+    case "nan":
+      return KIND_NUMBER;
+    case "boolean":
+      return KIND_BOOLEAN;
+    case "bigint":
+      return KIND_BIGINT;
+    case "date":
+      return KIND_DATE;
+    case "file":
+      return KIND_FILE;
+    case "null":
+      return KIND_NULL;
+    case "undefined":
+    case "void":
+      return KIND_UNDEFINED;
+    case "enum": {
+      const values = intro.getEnumValues(schema);
+      const out = /* @__PURE__ */ new Set();
+      for (const v of values) {
+        if (typeof v === "string") out.add("string");
+        else if (typeof v === "number") out.add("number");
+      }
+      return out.size === 0 ? KIND_STRING : out;
+    }
+    case "native-enum": {
+      const values = intro.getNativeEnumValues(schema);
+      if (values === void 0) return KIND_STRING;
+      const out = /* @__PURE__ */ new Set();
+      for (const v of Object.values(values)) {
+        if (typeof v === "string") out.add("string");
+        else if (typeof v === "number") out.add("number");
+      }
+      return out.size === 0 ? KIND_STRING : out;
+    }
+    case "literal": {
+      const values = intro.getLiteralValues(schema);
+      const out = /* @__PURE__ */ new Set();
+      for (const v of values) out.add(slimKindOf(v));
+      return out.size === 0 ? PERMISSIVE_SLIM_KINDS : out;
+    }
+    case "object":
+    case "record":
+      return KIND_OBJECT;
+    case "array":
+    case "tuple":
+      return KIND_ARRAY;
+    case "set":
+      return KIND_SET;
+    case "optional": {
+      const inner = intro.unwrapInner(schema);
+      const innerSet = inner === void 0 ? EMPTY_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
+      const out = new Set(innerSet);
+      out.add("undefined");
+      return out;
+    }
+    case "nullable": {
+      const inner = intro.unwrapInner(schema);
+      const innerSet = inner === void 0 ? EMPTY_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
+      const out = new Set(innerSet);
+      out.add("null");
+      return out;
+    }
+    case "default":
+    case "readonly":
+    case "catch": {
+      const inner = intro.unwrapInner(schema);
+      return inner === void 0 ? PERMISSIVE_SLIM_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
+    }
+    case "branded": {
+      const inner = intro.unwrapBranded(schema);
+      return inner === void 0 ? PERMISSIVE_SLIM_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
+    }
+    case "effects": {
+      const inner = intro.unwrapEffectsSource(schema);
+      return inner === void 0 ? PERMISSIVE_SLIM_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
+    }
+    case "pipeline": {
+      const inner = intro.unwrapPipeIn(schema);
+      return inner === void 0 ? PERMISSIVE_SLIM_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
+    }
+    case "pipe": {
+      const pipeIn = intro.unwrapPipeIn(schema);
+      const pipeOut = intro.unwrapPipeOut(schema);
+      const inner = pipeIn !== void 0 && intro.kindOf(pipeIn) === "transform" ? pipeOut : pipeIn ?? pipeOut;
+      return inner === void 0 ? PERMISSIVE_SLIM_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
+    }
+    case "lazy": {
+      if (lazyDepth >= maxDepth) return PERMISSIVE_SLIM_KINDS;
+      const inner = intro.unwrapLazy(schema);
+      return inner === void 0 ? PERMISSIVE_SLIM_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth + 1);
+    }
+    case "union":
+    case "discriminated-union": {
+      const options = intro.getUnionOptions(schema);
+      const out = /* @__PURE__ */ new Set();
+      for (const opt of options) {
+        for (const k of slimPrimitivesWalk(opt, intro, maxDepth, lazyDepth)) out.add(k);
+      }
+      return out.size === 0 ? PERMISSIVE_SLIM_KINDS : out;
+    }
+    case "intersection": {
+      const left = intro.getIntersectionLeft(schema);
+      const right = intro.getIntersectionRight(schema);
+      const leftSet = left === void 0 ? PERMISSIVE_SLIM_KINDS : slimPrimitivesWalk(left, intro, maxDepth, lazyDepth);
+      const rightSet = right === void 0 ? PERMISSIVE_SLIM_KINDS : slimPrimitivesWalk(right, intro, maxDepth, lazyDepth);
+      const out = /* @__PURE__ */ new Set();
+      for (const k of leftSet) if (rightSet.has(k)) out.add(k);
+      return out;
+    }
+    case "never":
+      return EMPTY_KINDS;
+    case "any":
+    case "unknown":
+      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.
+    default:
+      return PERMISSIVE_SLIM_KINDS;
+  }
+}
+
+export { NO_EMBEDDED_DEFAULT as N, getFieldMetaListForSchema as a, createAbstractSchema as c, deriveDefaultWalk as d, fieldMetaStore as f, getFieldMetaForSchema as g, mergeDeep as m, peelEmbeddedDefault as p, slimPrimitivesWalk as s, walkPathSegments as w };
+//# sourceMappingURL=attaform.tVkmQh5w.mjs.map