@zod-utils/core 7.1.0 → 7.2.0

package/README.md

@@ -23,6 +23,8 @@ npm install @zod-utils/core zod
 ## Features
 
 - **Extract defaults** - Get default values from Zod schemas
+- **Extract meta** - Get `.meta()` property values from schema fields
+- **Merge defaults with meta** - Combine defaults and meta into a single result
 - **Check validation requirements** - Determine if fields will error on empty input
 - **Extract validation checks** - Get all validation constraints (min/max, formats, patterns, etc.)
 - **Schema utilities** - Unwrap and manipulate schema types
@@ -83,6 +85,9 @@ npm install @zod-utils/core zod
       - [With Transforms](#with-transforms-2)
     - [`extendWithMeta(field, transform)`](#extendwithmetafield-transform)
       - [Use Case: Shared Field Definitions with i18n](#use-case-shared-field-definitions-with-i18n)
+    - [`extractMeta(field, metaKey)`](#extractmetafield-metakey)
+    - [`getSchemaMeta(params, metaKey)`](#getschemametaparams-metakey)
+    - [`getMergedSchemaDefaults(params, metaKey)`](#getmergedschemadefaultsparams-metakey)
     - [`toFieldSelector(props)`](#tofieldselectorprops)
   - [Type Utilities](#type-utilities)
     - [`Simplify<T>`](#simplifyt)
@@ -1004,6 +1009,145 @@ const editFormSchema = z.object({
 
 ---
 
+### `extractMeta(field, metaKey)`
+
+Extract the value of a specific meta key from a Zod field. Recursively unwraps optional, nullable, default, transform, and union layers.
+
+For `ZodObject` fields: if the object's own meta contains the target key, returns that value directly. Otherwise, recurses into shape children and returns a nested record.
+
+```typescript
+import { extractMeta } from "@zod-utils/core";
+import { z } from "zod";
+
+// Basic extraction
+const field = z.string().meta({ label: "Name" });
+extractMeta(field, "label"); // 'Name'
+
+// Unwraps through optional/nullable/default
+extractMeta(z.string().meta({ label: "Name" }).optional(), "label"); // 'Name'
+extractMeta(z.string().meta({ label: "Name" }).nullable(), "label"); // 'Name'
+extractMeta(z.string().meta({ label: "Name" }).default("hi"), "label"); // 'Name'
+
+// Nested objects: recurses when parent lacks the key
+const address = z.object({
+  city: z.string().meta({ label: "City" }),
+  zip: z.string().meta({ label: "Zip" }),
+});
+extractMeta(address, "label"); // { city: 'City', zip: 'Zip' }
+
+// Object's own meta stops recursion
+const labeled = address.meta({ label: "Address" });
+extractMeta(labeled, "label"); // 'Address'
+
+// Arrays: wraps element meta in an array
+extractMeta(z.array(z.string().meta({ label: "Tag" })), "label"); // ['Tag']
+
+// No meta returns undefined
+extractMeta(z.string(), "label"); // undefined
+```
+
+---
+
+### `getSchemaMeta(params, metaKey)`
+
+Extract the value of a specific meta key from all fields in a Zod schema. Supports discriminated unions via the `discriminator` parameter.
+
+```typescript
+import { getSchemaMeta } from "@zod-utils/core";
+import { z } from "zod";
+
+const schema = z.object({
+  name: z.string().meta({ label: "Name" }),
+  age: z.number().meta({ label: "Age" }),
+  bio: z.string(), // no meta
+});
+
+getSchemaMeta({ schema }, "label");
+// { name: 'Name', age: 'Age' }
+
+// With discriminated union
+const formSchema = z.discriminatedUnion("mode", [
+  z.object({
+    mode: z.literal("create"),
+    name: z.string().meta({ label: "Name" }),
+  }),
+  z.object({
+    mode: z.literal("edit"),
+    id: z.number().meta({ label: "ID" }),
+  }),
+]);
+
+getSchemaMeta(
+  { schema: formSchema, discriminator: { key: "mode", value: "create" } },
+  "label"
+);
+// { name: 'Name' }
+
+// With transforms
+const transformed = z
+  .object({ name: z.string().meta({ label: "Name" }) })
+  .transform((data) => ({ ...data, computed: true }));
+
+getSchemaMeta({ schema: transformed }, "label");
+// { name: 'Name' }
+```
+
+---
+
+### `getMergedSchemaDefaults(params, metaKey)`
+
+Combines schema defaults and meta values into a single result. Meta values take precedence over defaults where both exist. Performs a deep merge for nested objects.
+
+```typescript
+import { getMergedSchemaDefaults } from "@zod-utils/core";
+import { z } from "zod";
+
+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: '' }
+// 'name': meta 'Name' wins over default 'hello'
+// 'age': only meta exists
+// 'bio': only default exists
+
+// Deep merge preserves nested fields from both sources
+const nested = z.object({
+  address: z.object({
+    city: z.string().meta({ label: "City" }).default("NYC"),
+    zip: z.string().default("00000"),
+    state: z.string().meta({ label: "State" }),
+  }),
+});
+
+getMergedSchemaDefaults({ schema: nested }, "label");
+// { address: { city: 'City', zip: '00000', state: 'State' } }
+
+// Works with discriminated unions
+const formSchema = z.discriminatedUnion("mode", [
+  z.object({
+    mode: z.literal("create"),
+    name: z.string().meta({ label: "Name" }).default("New User"),
+    count: z.number().default(0),
+  }),
+  z.object({
+    mode: z.literal("edit"),
+    id: z.number().meta({ label: "ID" }),
+  }),
+]);
+
+getMergedSchemaDefaults(
+  { schema: formSchema, discriminator: { key: "mode", value: "create" } },
+  "label"
+);
+// { name: 'Name', count: 0 }
+```
+
+---
+
 ### `toFieldSelector(props)`
 
 Extracts a `FieldSelector` from props containing schema, name, and optional discriminator. Encapsulates type assertion so callers don't need eslint-disable.

package/dist/index.d.mts

@@ -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.
  *
@@ -710,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
  */
@@ -1053,4 +1167,4 @@ type ZodUnionCheck = $ZodCheckLessThanDef | $ZodCheckGreaterThanDef | $ZodCheckM
 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 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, 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.d.ts

@@ -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.
  *
@@ -710,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
  */
@@ -1053,4 +1167,4 @@ type ZodUnionCheck = $ZodCheckLessThanDef | $ZodCheckGreaterThanDef | $ZodCheckM
 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 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, 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

@@ -302,6 +302,95 @@ 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;
@@ -309,9 +398,13 @@ 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;