@zod-utils/core 7.0.1 → 7.2.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { z as z$1, util } from 'zod';
-import { SomeType, $InferUnionInput, $ZodCheckLessThanDef, $ZodCheckGreaterThanDef, $ZodCheckMultipleOfDef, $ZodCheckNumberFormatDef, $ZodCheckBigIntFormatDef, $ZodCheckMaxSizeDef, $ZodCheckMinSizeDef, $ZodCheckSizeEqualsDef, $ZodCheckMaxLengthDef, $ZodCheckMinLengthDef, $ZodCheckLengthEqualsDef, $ZodCheckStringFormatDef, $ZodCheckRegexDef, $ZodCheckLowerCaseDef, $ZodCheckUpperCaseDef, $ZodCheckIncludesDef, $ZodCheckStartsWithDef, $ZodCheckEndsWithDef, $ZodCheckPropertyDef, $ZodCheckMimeTypeDef, $ZodCheckOverwriteDef } from 'zod/v4/core';
+import { SomeType, $InferUnionInput, $ZodType, $ZodCheckLessThanDef, $ZodCheckGreaterThanDef, $ZodCheckMultipleOfDef, $ZodCheckNumberFormatDef, $ZodCheckMaxSizeDef, $ZodCheckMinSizeDef, $ZodCheckSizeEqualsDef, $ZodCheckMaxLengthDef, $ZodCheckMinLengthDef, $ZodCheckLengthEqualsDef, $ZodCheckStringFormatDef, $ZodCheckRegexDef, $ZodCheckIncludesDef, $ZodCheckStartsWithDef, $ZodCheckEndsWithDef, $ZodCheckMimeTypeDef, $ZodCheckOverwriteDef } from 'zod/v4/core';
 
 /**
  * Simplifies complex TypeScript types for better IDE hover tooltips and error messages.
@@ -365,6 +365,11 @@ type NameAndDiscriminatorProps<TSchema extends z$1.ZodType, TDiscriminatorKey ex
  */
 type FieldSelectorProps<TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true> = SchemaProps<TSchema> & NameAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>;
 
+/**
+ * Type-safe helper to iterate over ZodObject shape entries.
+ * @internal
+ */
+declare function getShapeEntries(schema: z.ZodObject): Array<[string, z.ZodType | undefined]>;
 /**
  * Extracts the default value from a Zod field, recursively unwrapping optional, nullable, and union layers.
  *
@@ -650,19 +655,45 @@ type ExtractZodUnionMember<TSchema extends z$1.ZodUnion | z$1.ZodDiscriminatedUn
  * @see {@link ExtractZodUnionMember} for the type-level extraction logic
  * @since 0.6.0
  */
-declare const extractDiscriminatedSchema: <TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, ReturnType extends TSchema extends z$1.ZodDiscriminatedUnion ? ExtractZodUnionMember<TSchema, TDiscriminatorKey, TDiscriminatorValue> : never>({ schema, discriminator, }: SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue>) => ReturnType | undefined;
+declare const extractDiscriminatedSchema: <TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TUnwrapped extends z$1.ZodType = UnwrapZodType<TSchema> extends z$1.ZodType ? UnwrapZodType<TSchema> : TSchema, ReturnType extends TUnwrapped extends z$1.ZodDiscriminatedUnion ? ExtractZodUnionMember<TUnwrapped, Extract<TDiscriminatorKey, DiscriminatorKey<TUnwrapped>>, Extract<TDiscriminatorValue, DiscriminatorValue<TUnwrapped, Extract<TDiscriminatorKey, DiscriminatorKey<TUnwrapped>>>>> : undefined = TUnwrapped extends z$1.ZodDiscriminatedUnion ? ExtractZodUnionMember<TUnwrapped, Extract<TDiscriminatorKey, DiscriminatorKey<TUnwrapped>>, Extract<TDiscriminatorValue, DiscriminatorValue<TUnwrapped, Extract<TDiscriminatorKey, DiscriminatorKey<TUnwrapped>>>>> : undefined>({ schema, discriminator, }: SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue>) => ReturnType;
 
 type Split<S extends string> = S extends `${infer Head}.${infer Tail}` ? [Head, ...Split<Tail>] : [S];
 type IsNumeric<S extends string> = S extends `${number}` ? true : false;
-type Unwrap<T> = T extends z$1.ZodOptional<infer U> ? Unwrap<U> : T extends z$1.ZodNullable<infer U> ? Unwrap<U> : T extends z$1.ZodDefault<infer U> ? Unwrap<U> : T;
+type Unwrap<T> = T extends z$1.ZodOptional<infer U> ? Unwrap<U> : T extends z$1.ZodNullable<infer U> ? Unwrap<U> : T extends z$1.ZodDefault<infer U> ? Unwrap<U> : T extends z$1.ZodPipe<infer In, z$1.ZodType> ? Unwrap<In> : T;
 type NavigateZod<T, Path extends string[]> = Path extends [
     infer First extends string,
     ...infer Rest extends string[]
 ] ? Unwrap<T> extends z$1.ZodObject<infer Shape> ? First extends keyof Shape ? Rest extends [] ? Shape[First] : NavigateZod<Shape[First], Rest> : never : Unwrap<T> extends z$1.ZodArray<infer Element> ? IsNumeric<First> extends true ? Rest extends [] ? Element : NavigateZod<Element, Rest> : never : never : T;
 type ExtractZodByPath<Schema, Path extends string> = NavigateZod<Schema, Split<Path>>;
+/**
+ * Extract field from a discriminated union variant.
+ * First extracts the variant using ExtractZodUnionMember, then navigates through it.
+ * @internal
+ */
+type ExtractFromDiscriminatedUnion<TSchema extends z$1.ZodType, TName extends string, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TUnwrapped extends z$1.ZodType = UnwrapZodType<TSchema> extends z$1.ZodType ? UnwrapZodType<TSchema> : TSchema, TVariant = TUnwrapped extends z$1.ZodDiscriminatedUnion ? ExtractZodUnionMember<TUnwrapped, Extract<TDiscriminatorKey, DiscriminatorKey<TUnwrapped>>, Extract<TDiscriminatorValue, DiscriminatorValue<TUnwrapped, Extract<TDiscriminatorKey, DiscriminatorKey<TUnwrapped>>>>> : never> = TVariant extends z$1.ZodType ? ExtractZodByPath<TVariant, TName> : never;
+/**
+ * Helper type to determine if field extraction should succeed.
+ * Returns true when:
+ * 1. For discriminated unions: discriminator is provided (trust the user)
+ * 2. For non-unions: the path resolves to a valid type (not never)
+ * @internal
+ */
+type CanExtractField<TSchema extends z$1.ZodType, TName extends string, TDiscriminatorKey extends DiscriminatorKey<TSchema>> = IsDiscriminatedUnion<TSchema> extends true ? [TDiscriminatorKey] extends [never] ? false : true : [
+    ExtractZodByPath<TSchema, TName>
+] extends [never] ? false : true;
+/**
+ * Conditional return type for extractFieldFromSchema.
+ * For discriminated unions: extracts variant first, then navigates.
+ * For non-unions: navigates directly.
+ * @internal
+ */
+type ExtractFieldResult<TSchema extends z$1.ZodType, TName extends string, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = DiscriminatorValue<TSchema, TDiscriminatorKey>> = CanExtractField<TSchema, TName, TDiscriminatorKey> extends true ? IsDiscriminatedUnion<TSchema> extends true ? [
+    ExtractFromDiscriminatedUnion<TSchema, TName, TDiscriminatorKey, TDiscriminatorValue>
+] extends [never] ? z$1.ZodType : ExtractFromDiscriminatedUnion<TSchema, TName, TDiscriminatorKey, TDiscriminatorValue> & z$1.ZodType : // For non-unions: navigate directly
+ExtractZodByPath<TSchema, TName> & z$1.ZodType : (ExtractZodByPath<TSchema, TName> & z$1.ZodType) | undefined;
 declare function extractFieldFromSchema<TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true, TName extends string = string>(params: FieldSelectorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> & {
     name: TName;
-}): (ExtractZodByPath<TSchema, TName> & z$1.ZodType) | undefined;
+}): ExtractFieldResult<TSchema, TName, TDiscriminatorKey, TDiscriminatorValue>;
 /**
  * Extends a Zod field with a transformation while preserving its metadata.
  *
@@ -684,6 +715,115 @@ declare function extractFieldFromSchema<TSchema extends z$1.ZodType, TDiscrimina
  */
 declare function extendWithMeta<T extends z$1.ZodType, R extends z$1.ZodType>(field: T, transform: (f: T) => R): R;
 
+/**
+ * Extracts the value of a specific meta key from a Zod field, recursively unwrapping
+ * optional, nullable, default, transform, and union layers.
+ *
+ * For `ZodObject` fields: if the object's own meta contains the target key, returns that
+ * value directly (stops recursion). If not, recurses into shape children and returns
+ * a nested record of meta values.
+ *
+ * @param field - The Zod field to extract meta from
+ * @param metaKey - The meta property key to extract
+ * @returns The meta value if found, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * const field = z.string().meta({ label: 'Name' });
+ * extractMeta(field, 'label'); // 'Name'
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const field = z.string().meta({ label: 'Name' }).optional();
+ * extractMeta(field, 'label'); // 'Name' (unwraps optional)
+ * ```
+ *
+ * @see {@link getSchemaMeta} for extracting meta from entire schemas
+ * @since 0.3.0
+ */
+declare function extractMeta(field: z.ZodType, metaKey: string): unknown;
+/**
+ * Extracts the value of a specific meta key from all fields in a Zod schema.
+ *
+ * Returns a nested record where each key maps to the meta value for that field.
+ * Fields without the specified meta key are omitted.
+ *
+ * For `ZodObject` fields: if the object has the target meta key in its own meta,
+ * returns that value directly. Otherwise, recurses into shape children.
+ *
+ * Supports discriminated unions via the `discriminator` parameter.
+ *
+ * @param params - Schema and optional discriminator configuration
+ * @param metaKey - The meta property key to extract
+ * @returns Record mapping field names to their meta values
+ *
+ * To get typed meta keys with autocomplete, augment Zod's `GlobalMeta` interface:
+ *
+ * ```typescript
+ * // types/zod.ts
+ * import * as z from 'zod';
+ *
+ * declare module 'zod' {
+ *   interface GlobalMeta {
+ *     label: string;               // static type for all schemas
+ *     type: z.$output;             // resolves to the schema's output type
+ *     inputType: z.$input;         // resolves to the schema's input type
+ *     placeholder?: string;
+ *   }
+ * }
+ * ```
+ *
+ * With `z.$output` / `z.$input`, Zod automatically types `.meta()` values
+ * based on each schema's inferred type:
+ *
+ * ```typescript
+ * z.string().meta({ type: 'hello' })  // ✅ type is string
+ * z.string().meta({ type: 42 })       // ❌ TypeScript error — expects string
+ * z.number().meta({ type: 42 })       // ✅ type is number
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const schema = z.object({
+ *   name: z.string().meta({ label: 'Name' }),
+ *   age: z.number().meta({ label: 'Age' }),
+ * });
+ * getSchemaMeta({ schema }, 'label');
+ * // { name: 'Name', age: 'Age' }
+ * ```
+ *
+ * @see {@link extractMeta} for extracting meta from individual fields
+ * @since 0.3.0
+ */
+declare function getSchemaMeta<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>>(params: SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue>, metaKey: string): Simplify<Partial<z.input<TSchema>>>;
+/**
+ * Combines schema defaults and meta values into a single result.
+ * Meta values take precedence over defaults where both exist.
+ * For nested objects, performs a deep merge so that fields from both
+ * sources are preserved at every level.
+ *
+ * @param params - Schema and optional discriminator configuration
+ * @param metaKey - The meta property key to extract
+ * @returns Deep-merged record of defaults and meta values (meta wins on conflict)
+ *
+ * @example
+ * ```typescript
+ * const schema = z.object({
+ *   name: z.string().meta({ label: 'Name' }).default('hello'),
+ *   age: z.number().meta({ label: 'Age' }),
+ *   bio: z.string().default(''),
+ * });
+ * getMergedSchemaDefaults({ schema }, 'label');
+ * // { name: 'Name', age: 'Age', bio: '' }
+ * ```
+ *
+ * @see {@link getSchemaDefaults} for extracting only defaults
+ * @see {@link getSchemaMeta} for extracting only meta
+ * @since 0.5.0
+ */
+declare function getMergedSchemaDefaults<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>>(params: SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue>, metaKey: string): Simplify<Partial<z.input<TSchema>>>;
+
 /**
  * Type representing a Zod type that has an unwrap method
  */
@@ -710,7 +850,7 @@ type Unwrappable = {
  *
  * @since 0.1.0
  */
-declare function canUnwrap(field: z$1.ZodTypeAny): field is z$1.ZodTypeAny & Unwrappable;
+declare function canUnwrap(field: z$1.ZodType | $ZodType): field is (z$1.ZodType | $ZodType) & Unwrappable;
 /**
  * Type guard that checks if a Zod field is a ZodPipe with a ZodType input.
  *
@@ -719,7 +859,7 @@ declare function canUnwrap(field: z$1.ZodTypeAny): field is z$1.ZodTypeAny & Unw
  * @param field - The Zod field to check
  * @returns True if field is a ZodPipe with a ZodType input
  */
-declare function isPipeWithZodInput(field: z$1.ZodTypeAny): field is z$1.ZodPipe<z$1.ZodType, z$1.ZodTypeAny>;
+declare function isPipeWithZodInput(field: z$1.ZodType | $ZodType): field is z$1.ZodPipe<z$1.ZodType, z$1.ZodTypeAny>;
 /**
  * Attempts to strip nullish types from a union and return the single remaining type.
  *
@@ -816,7 +956,7 @@ declare function tryStripNullishOnly(field: z$1.ZodTypeAny): z$1.ZodType | false
  * @see {@link tryStripNullishOnly} for union nullish stripping logic
  * @since 0.1.0
  */
-declare const getPrimitiveType: <T extends z$1.ZodType>(field: T) => z$1.ZodTypeAny;
+declare const getPrimitiveType: <T extends z$1.ZodType>(field: T) => z$1.ZodType;
 type StripZodDefault<T> = T extends z$1.ZodDefault<infer Inner> ? StripZodDefault<Inner> : T extends z$1.ZodOptional<infer Inner> ? z$1.ZodOptional<StripZodDefault<Inner>> : T extends z$1.ZodNullable<infer Inner> ? z$1.ZodNullable<StripZodDefault<Inner>> : T;
 /**
  * Removes default values from a Zod field while preserving other wrapper types.
@@ -948,7 +1088,7 @@ declare const requiresValidInput: <T extends z$1.ZodType>(field: T) => boolean;
  *
  * @since 0.4.0
  */
-type ZodUnionCheck = $ZodCheckLessThanDef | $ZodCheckGreaterThanDef | $ZodCheckMultipleOfDef | $ZodCheckNumberFormatDef | $ZodCheckBigIntFormatDef | $ZodCheckMaxSizeDef | $ZodCheckMinSizeDef | $ZodCheckSizeEqualsDef | $ZodCheckMaxLengthDef | $ZodCheckMinLengthDef | $ZodCheckLengthEqualsDef | $ZodCheckStringFormatDef | $ZodCheckRegexDef | $ZodCheckLowerCaseDef | $ZodCheckUpperCaseDef | $ZodCheckIncludesDef | $ZodCheckStartsWithDef | $ZodCheckEndsWithDef | $ZodCheckPropertyDef | $ZodCheckMimeTypeDef | $ZodCheckOverwriteDef;
+type ZodUnionCheck = $ZodCheckLessThanDef | $ZodCheckGreaterThanDef | $ZodCheckMultipleOfDef | $ZodCheckNumberFormatDef | $ZodCheckMaxSizeDef | $ZodCheckMinSizeDef | $ZodCheckSizeEqualsDef | $ZodCheckMaxLengthDef | $ZodCheckMinLengthDef | $ZodCheckLengthEqualsDef | $ZodCheckStringFormatDef | $ZodCheckRegexDef | $ZodCheckIncludesDef | $ZodCheckStartsWithDef | $ZodCheckEndsWithDef | $ZodCheckMimeTypeDef | $ZodCheckOverwriteDef;
 /**
  * Extracts all validation check definitions from a Zod schema field.
  *
@@ -1024,6 +1164,7 @@ type ZodUnionCheck = $ZodCheckLessThanDef | $ZodCheckGreaterThanDef | $ZodCheckM
  * @see {@link ZodUnionCheck} for all supported check types
  * @since 0.4.0
  */
-declare function getFieldChecks<T extends z$1.ZodTypeAny>(field: T): Array<ZodUnionCheck>;
+declare function getFieldChecks<T extends z$1.ZodType | $ZodType>(field: T): Array<ZodUnionCheck>;
+declare function extractCheck(check: z$1.core.$ZodCheck<never>): ZodUnionCheck[];
 
-export { type CommonFields, type DiscriminatedInput, type DiscriminatorKey, type DiscriminatorProps, type DiscriminatorValue, type ExtractZodByPath, type FieldSelectorProps, type FileList, type IsDiscriminatedUnion, type NameAndDiscriminatorProps, type NameProps, type PathImpl, type PathInternal, type Paths, type SchemaAndDiscriminatorProps, type SchemaProps, type Simplify, type UnwrapZodType, type ValidPaths, type ZodUnionCheck, canUnwrap, extendWithMeta, extractDefaultValue, extractDiscriminatedSchema, extractFieldFromSchema, getFieldChecks, getPrimitiveType, getSchemaDefaults, isPipeWithZodInput, removeDefault, requiresValidInput, tryStripNullishOnly };
+export { type CommonFields, type DiscriminatedInput, type DiscriminatorKey, type DiscriminatorProps, type DiscriminatorValue, type ExtractZodByPath, type ExtractZodUnionMember, type FieldSelectorProps, type FileList, type IsDiscriminatedUnion, type NameAndDiscriminatorProps, type NameProps, type PathImpl, type PathInternal, type Paths, type SchemaAndDiscriminatorProps, type SchemaProps, type Simplify, type UnwrapZodType, type ValidPaths, type ZodUnionCheck, canUnwrap, extendWithMeta, extractCheck, extractDefaultValue, extractDiscriminatedSchema, extractFieldFromSchema, extractMeta, getFieldChecks, getMergedSchemaDefaults, getPrimitiveType, getSchemaDefaults, getSchemaMeta, getShapeEntries, isPipeWithZodInput, removeDefault, requiresValidInput, tryStripNullishOnly };

package/dist/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var z3 = require('zod');
+var core = require('zod/v4/core');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -110,9 +111,65 @@ var requiresValidInput = (field) => {
   return !undefinedResult && !nullResult && !emptyStringResult && !emptyArrayResult;
 };
 function getFieldChecks(field) {
-  var _a;
+  if (!(field instanceof z3.z.ZodType)) return [];
   const primitiveType = getPrimitiveType(field);
-  return ((_a = primitiveType.def.checks) == null ? void 0 : _a.map((check) => check._zod.def)) || [];
+  if (primitiveType instanceof z3.z.ZodUnion) {
+    const allChecks2 = [];
+    for (const option of primitiveType.options) {
+      const optionChecks = getFieldChecks(option);
+      allChecks2.push(...optionChecks);
+    }
+    return allChecks2;
+  }
+  const allChecks = [];
+  if (primitiveType instanceof z3.ZodStringFormat) {
+    const formatCheck = primitiveType.def;
+    allChecks.push(formatCheck);
+  }
+  if (primitiveType.def.checks) {
+    for (const check of primitiveType.def.checks) {
+      allChecks.push(...extractCheck(check));
+    }
+  }
+  return allChecks;
+}
+function extractCheck(check) {
+  if (check instanceof core.$ZodCheckLessThan) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckGreaterThan) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckMultipleOf) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckNumberFormat) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckMaxSize) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckMinSize) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckSizeEquals) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckMaxLength) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckMinLength) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckLengthEquals) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckRegex) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckStringFormat) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckOverwrite) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckMimeType) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckIncludes) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckStartsWith) {
+    return [check._zod.def];
+  } else if (check instanceof core.$ZodCheckEndsWith) {
+    return [check._zod.def];
+  }
+  return [];
 }
 
 // src/discriminatedSchema.ts
@@ -216,10 +273,12 @@ function extractFieldFromSchema(params) {
   } else if (newParams.schema instanceof z3.z.ZodObject) {
     currentSchema = newParams.schema;
   }
-  if (!currentSchema) return void 0;
+  if (!currentSchema)
+    return void 0;
   const segments = String(newParams.name).split(".");
   for (const segment of segments) {
-    if (!currentSchema) return void 0;
+    if (!currentSchema)
+      return void 0;
     const unwrapped = getPrimitiveType(currentSchema);
     if (unwrapped instanceof z3.z.ZodObject) {
       currentSchema = getShapeField2(unwrapped, segment);
@@ -243,15 +302,109 @@ function extendWithMeta(field, transform) {
   }
   return transformedField.meta(__spreadValues({}, meta));
 }
+function extractMeta(field, metaKey) {
+  const meta = field.meta();
+  if (meta && metaKey in meta) {
+    return meta[metaKey];
+  }
+  if (field instanceof z3__namespace.ZodObject) {
+    const nested = {};
+    let hasAny = false;
+    for (const [key, nestedField] of getShapeEntries(field)) {
+      if (!nestedField) continue;
+      const value = extractMeta(nestedField, metaKey);
+      if (value !== void 0) {
+        nested[key] = value;
+        hasAny = true;
+      }
+    }
+    if (hasAny) {
+      return nested;
+    }
+    return void 0;
+  }
+  if (field instanceof z3__namespace.ZodArray) {
+    const elementMeta = extractMeta(field.unwrap(), metaKey);
+    if (elementMeta !== void 0) {
+      return [elementMeta];
+    }
+    return void 0;
+  }
+  if (canUnwrap(field)) {
+    return extractMeta(field.unwrap(), metaKey);
+  }
+  if (field instanceof z3__namespace.ZodUnion) {
+    const unwrapped = tryStripNullishOnly(field);
+    if (unwrapped !== false) {
+      return extractMeta(unwrapped, metaKey);
+    }
+    return void 0;
+  }
+  if (isPipeWithZodInput(field)) {
+    return extractMeta(field.def.in, metaKey);
+  }
+  return void 0;
+}
+function getSchemaMeta(params, metaKey) {
+  const primitiveSchemaParams = __spreadProps(__spreadValues({}, params), {
+    schema: getPrimitiveType(params.schema)
+  });
+  let targetSchema;
+  if (primitiveSchemaParams.schema instanceof z3__namespace.ZodDiscriminatedUnion) {
+    targetSchema = extractDiscriminatedSchema(primitiveSchemaParams);
+  } else if (primitiveSchemaParams.schema instanceof z3__namespace.ZodObject) {
+    targetSchema = primitiveSchemaParams.schema;
+  }
+  const result = {};
+  if (targetSchema) {
+    for (const [key, field] of getShapeEntries(targetSchema)) {
+      if (!field) continue;
+      const value = extractMeta(field, metaKey);
+      if (value !== void 0) {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(target, source) {
+  const result = __spreadValues({}, target);
+  for (const key of Object.keys(source)) {
+    const targetVal = target[key];
+    const sourceVal = source[key];
+    if (isPlainObject(targetVal) && isPlainObject(sourceVal)) {
+      result[key] = deepMerge(targetVal, sourceVal);
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+function getMergedSchemaDefaults(params, metaKey) {
+  const defaults = getSchemaDefaults(params);
+  const meta = getSchemaMeta(params, metaKey);
+  return deepMerge(
+    defaults,
+    meta
+  );
+}
 
 exports.canUnwrap = canUnwrap;
 exports.extendWithMeta = extendWithMeta;
+exports.extractCheck = extractCheck;
 exports.extractDefaultValue = extractDefaultValue;
 exports.extractDiscriminatedSchema = extractDiscriminatedSchema;
 exports.extractFieldFromSchema = extractFieldFromSchema;
+exports.extractMeta = extractMeta;
 exports.getFieldChecks = getFieldChecks;
+exports.getMergedSchemaDefaults = getMergedSchemaDefaults;
 exports.getPrimitiveType = getPrimitiveType;
 exports.getSchemaDefaults = getSchemaDefaults;
+exports.getSchemaMeta = getSchemaMeta;
+exports.getShapeEntries = getShapeEntries;
 exports.isPipeWithZodInput = isPipeWithZodInput;
 exports.removeDefault = removeDefault;
 exports.requiresValidInput = requiresValidInput;