@kubb/plugin-zod 5.0.0-beta.42 → 5.0.0-beta.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-zod",
-  "version": "5.0.0-beta.42",
+  "version": "5.0.0-beta.56",
   "description": "Generate Zod validation schemas from your OpenAPI specification for runtime data parsing and type safety. Pairs perfectly with @kubb/plugin-ts for end-to-end type coverage.",
   "keywords": [
     "code-generation",
@@ -26,7 +26,6 @@
     "src",
     "templates",
     "dist",
-    "extension.yaml",
     "!/**/**.test.**",
     "!/**/__tests__/**",
     "!/**/__snapshots__/**"
@@ -48,29 +47,23 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/core": "5.0.0-beta.42",
-    "@kubb/renderer-jsx": "5.0.0-beta.42"
+    "@kubb/ast": "5.0.0-beta.55",
+    "@kubb/core": "5.0.0-beta.55",
+    "@kubb/renderer-jsx": "5.0.0-beta.55"
   },
   "devDependencies": {
-    "@internals/shared": "0.0.0",
-    "@internals/utils": "0.0.0"
+    "@internals/utils": "0.0.0",
+    "@internals/shared": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.42"
+    "@kubb/renderer-jsx": "5.0.0-beta.55"
   },
-  "size-limit": [
-    {
-      "path": "./dist/*.js",
-      "limit": "510 KiB",
-      "gzip": true
-    }
-  ],
   "engines": {
     "node": ">=22"
   },
   "scripts": {
-    "build": "tsdown && size-limit",
-    "clean": "npx rimraf ./dist",
+    "build": "tsdown",
+    "clean": "node -e \"require('node:fs').rmSync('./dist', {recursive:true,force:true})\"",
     "lint": "oxlint .",
     "lint:fix": "oxlint --fix .",
     "release": "pnpm publish --no-git-check",

package/src/components/Operations.tsx

@@ -1,4 +1,4 @@
-import { stringifyObject } from '@internals/utils'
+import { stringifyObject } from '@kubb/ast/utils'
 import { ast } from '@kubb/core'
 import { Const, File, Type } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'

package/src/generators/zodGenerator.tsx

@@ -1,8 +1,9 @@
 import { resolveContentTypeVariants } from '@internals/shared'
+import { extractRefName } from '@kubb/ast/utils'
 import type { Adapter } from '@kubb/core'
 import { ast, defineGenerator } from '@kubb/core'
 import type { AdapterOas } from '@kubb/adapter-oas'
-import { File, jsxRendererSync } from '@kubb/renderer-jsx'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { Operations } from '../components/Operations.tsx'
 import { Zod } from '../components/Zod.tsx'
 import { ZOD_NAMESPACE_IMPORTS } from '../constants.ts'
@@ -54,7 +55,7 @@ function getMiniPrinter(resolver: ResolverZod, params: { guidType: unknown; wrap
  */
 export const zodGenerator = defineGenerator<PluginZod>({
   name: 'zod',
-  renderer: jsxRendererSync,
+  renderer: jsxRenderer,
   schema(node, ctx) {
     const { adapter, config, resolver, root } = ctx
     const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options
@@ -64,7 +65,6 @@ export const zodGenerator = defineGenerator<PluginZod>({
       return
     }
 
-    const mode = ctx.getMode(output)
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
     const cyclicSchemas = new Set<string>(ctx.meta.circularNames)
 
@@ -75,7 +75,7 @@ export const zodGenerator = defineGenerator<PluginZod>({
     const codecRefNames = new Set(
       hasCodec
         ? ast.collect<string>(node, {
-            schema: (n) => (n.type === 'ref' && n.ref && containsCodec(n) ? (ast.extractRefName(n.ref) ?? undefined) : undefined),
+            schema: (n) => (n.type === 'ref' && n.ref && containsCodec(n) ? (extractRefName(n.ref) ?? undefined) : undefined),
           })
         : [],
     )
@@ -85,7 +85,7 @@ export const zodGenerator = defineGenerator<PluginZod>({
     }))
     const inputImportEntries = hasCodec
       ? [...codecRefNames].map((schemaName) => ({
-          name: resolver.resolveInputSchemaName(schemaName),
+          name: [resolver.resolveInputSchemaName(schemaName)],
           path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }).path,
         }))
       : []
@@ -116,8 +116,9 @@ export const zodGenerator = defineGenerator<PluginZod>({
         footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
       >
         <File.Import name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
-        {mode === 'split' &&
-          imports.map((imp) => <File.Import key={[node.name, imp.path, imp.name].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
+        {imports.map((imp) => (
+          <File.Import key={[node.name, imp.path, imp.name].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />
+        ))}
 
         <Zod name={meta.name} node={node} printer={schemaPrinter} inferTypeName={inferTypeName} />
         {hasCodec && stdPrinters && (
@@ -137,7 +138,6 @@ export const zodGenerator = defineGenerator<PluginZod>({
     const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = ctx.options
     const dateType = (adapter as Adapter<AdapterOas>).options.dateType
 
-    const mode = ctx.getMode(output)
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
     const params = ast.caseParams(node.parameters, paramsCasing)
@@ -171,7 +171,7 @@ export const zodGenerator = defineGenerator<PluginZod>({
         direction === 'input' && !mini
           ? new Set(
               ast.collect<string>(schema, {
-                schema: (n) => (n.type === 'ref' && n.ref && containsCodec(n) ? (ast.extractRefName(n.ref) ?? undefined) : undefined),
+                schema: (n) => (n.type === 'ref' && n.ref && containsCodec(n) ? (extractRefName(n.ref) ?? undefined) : undefined),
               }),
             )
           : null
@@ -190,8 +190,9 @@ export const zodGenerator = defineGenerator<PluginZod>({
 
       return (
         <>
-          {mode === 'split' &&
-            imports.map((imp) => <File.Import key={[name, imp.path, imp.name].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
+          {imports.map((imp) => (
+            <File.Import key={[name, imp.path, imp.name].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />
+          ))}
           <Zod name={name} node={schema} printer={schemaPrinter} inferTypeName={inferTypeName} />
         </>
       )

package/src/plugin.ts

@@ -37,7 +37,7 @@ export const pluginZodName = 'plugin-zod' satisfies PluginZod['name']
  */
 export const pluginZod = definePlugin<PluginZod>((options) => {
   const {
-    output = { path: 'zod', barrelType: 'named' },
+    output = { path: 'zod', barrel: { type: 'named' } },
     group,
     exclude = [],
     include,
@@ -57,7 +57,7 @@ export const pluginZod = definePlugin<PluginZod>((options) => {
     generators: userGenerators = [],
   } = options
 
-  const groupConfig = createGroupConfig(group, { suffix: 'Controller' })
+  const groupConfig = createGroupConfig(group)
 
   return {
     name: pluginZodName,

package/src/printers/printerZod.ts

@@ -1,4 +1,4 @@
-import { stringify } from '@internals/utils'
+import { buildList, buildObject, extractRefName, objectKey, stringify } from '@kubb/ast/utils'
 
 import { ast } from '@kubb/core'
 import type { PluginZod, ResolverZod } from '../types.ts'
@@ -203,7 +203,7 @@ export const printerZod = ast.definePrinter<PrinterZodFactory>((options) => {
       },
       ref(node) {
         if (!node.name) return null
-        const refName = node.ref ? (ast.extractRefName(node.ref) ?? node.name) : node.name
+        const refName = node.ref ? (extractRefName(node.ref) ?? node.name) : node.name
 
         // In the input direction, a date-bearing component resolves to its `${name}InputSchema`
         // variant so request bodies encode `Date → string` instead of decoding.
@@ -221,50 +221,48 @@ export const printerZod = ast.definePrinter<PrinterZodFactory>((options) => {
         return resolvedName
       },
       object(node) {
-        const properties = node.properties
-          .map((prop) => {
-            const { name: propName, schema } = prop
-
-            const meta = ast.syncSchemaRef(schema)
-
-            const isNullable = meta.nullable
-            const isOptional = schema.optional
-            const isNullish = schema.nullish
-
-            const hasSelfRef = this.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas })
-            // Inside a getter the getter itself defers evaluation, so suppress
-            // z.lazy() wrapping on nested refs by temporarily clearing cyclicSchemas.
-            // Save before clearing: this.options === options (same reference via definePrinter),
-            // so reading options.cyclicSchemas after mutation would return undefined.
-            const savedCyclicSchemas = this.options.cyclicSchemas
-            if (hasSelfRef) this.options.cyclicSchemas = undefined
-            const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: 'unknown' }))!
-            if (hasSelfRef) this.options.cyclicSchemas = savedCyclicSchemas
-
-            const wrappedOutput = this.options.wrapOutput ? this.options.wrapOutput({ output: baseOutput, schema }) || baseOutput : baseOutput
-
-            // When a property schema is not a ref but the metadata is from a ref (e.g., discriminator
-            // property override), skip applying the description from the ref target to avoid applying
-            // metadata from a replaced schema.
-            const descriptionToApply = schema.type !== 'ref' && meta.type === 'ref' ? undefined : meta.description
-
-            const value = applyModifiers({
-              value: wrappedOutput,
-              nullable: isNullable,
-              optional: isOptional,
-              nullish: isNullish,
-              defaultValue: meta.default,
-              description: descriptionToApply,
-            })
-
-            if (hasSelfRef) {
-              return `get "${propName}"() { return ${value} }`
-            }
-            return `"${propName}": ${value}`
+        const entries = node.properties.map((prop) => {
+          const { name: propName, schema } = prop
+
+          const meta = ast.syncSchemaRef(schema)
+
+          const isNullable = meta.nullable
+          const isOptional = schema.optional
+          const isNullish = schema.nullish
+
+          const hasSelfRef = this.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas })
+          // Inside a getter the getter itself defers evaluation, so suppress
+          // z.lazy() wrapping on nested refs by temporarily clearing cyclicSchemas.
+          // Save before clearing: this.options === options (same reference via definePrinter),
+          // so reading options.cyclicSchemas after mutation would return undefined.
+          const savedCyclicSchemas = this.options.cyclicSchemas
+          if (hasSelfRef) this.options.cyclicSchemas = undefined
+          const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: 'unknown' }))!
+          if (hasSelfRef) this.options.cyclicSchemas = savedCyclicSchemas
+
+          const wrappedOutput = this.options.wrapOutput ? this.options.wrapOutput({ output: baseOutput, schema }) || baseOutput : baseOutput
+
+          // When a property schema is not a ref but the metadata is from a ref (e.g., discriminator
+          // property override), skip applying the description from the ref target to avoid applying
+          // metadata from a replaced schema.
+          const descriptionToApply = schema.type !== 'ref' && meta.type === 'ref' ? undefined : meta.description
+
+          const value = applyModifiers({
+            value: wrappedOutput,
+            nullable: isNullable,
+            optional: isOptional,
+            nullish: isNullish,
+            defaultValue: meta.default,
+            description: descriptionToApply,
           })
-          .join(',\n    ')
 
-        const objectBase = `z.object({\n    ${properties}\n    })`
+          if (hasSelfRef) {
+            return `get ${objectKey(propName)}() { return ${value} }`
+          }
+          return `${objectKey(propName)}: ${value}`
+        })
+
+        const objectBase = `z.object(${buildObject(entries)})`
 
         // Handle additionalProperties as .catchall() or .strict()
         const result = (() => {
@@ -289,7 +287,7 @@ export const printerZod = ast.definePrinter<PrinterZodFactory>((options) => {
       tuple(node) {
         const items = (node.items ?? []).map((item) => this.transform(item)).filter(Boolean)
 
-        return `z.tuple([${items.join(', ')}])`
+        return `z.tuple(${buildList(items)})`
       },
       union(node) {
         const nodeMembers = node.members ?? []
@@ -305,10 +303,10 @@ export const printerZod = ast.definePrinter<PrinterZodFactory>((options) => {
         if (node.discriminatorPropertyName && !nodeMembers.some((m) => m.type === 'intersection')) {
           // z.discriminatedUnion requires ZodObject members; intersections (ZodIntersection) are not
           // assignable to $ZodDiscriminant, so fall back to z.union when any member is an intersection.
-          return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, [${members.join(', ')}])`
+          return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`
         }
 
-        return `z.union([${members.join(', ')}])`
+        return `z.union(${buildList(members)})`
       },
       intersection(node) {
         const members = node.members ?? []

package/src/printers/printerZodMini.ts

@@ -1,4 +1,4 @@
-import { stringify } from '@internals/utils'
+import { buildList, buildObject, extractRefName, objectKey, stringify } from '@kubb/ast/utils'
 
 import { ast } from '@kubb/core'
 import type { PluginZod, ResolverZod } from '../types.ts'
@@ -161,7 +161,7 @@ export const printerZodMini = ast.definePrinter<PrinterZodMiniFactory>((options)
 
       ref(node) {
         if (!node.name) return null
-        const refName = node.ref ? (ast.extractRefName(node.ref) ?? node.name) : node.name
+        const refName = node.ref ? (extractRefName(node.ref) ?? node.name) : node.name
         const resolvedName = node.ref ? (this.options.resolver?.default(refName, 'function') ?? refName) : node.name
 
         if (node.ref && this.options.cyclicSchemas?.has(refName)) {
@@ -171,44 +171,42 @@ export const printerZodMini = ast.definePrinter<PrinterZodMiniFactory>((options)
         return resolvedName
       },
       object(node) {
-        const properties = node.properties
-          .map((prop) => {
-            const { name: propName, schema } = prop
-
-            const meta = ast.syncSchemaRef(schema)
-
-            const isNullable = meta.nullable
-            const isOptional = schema.optional
-            const isNullish = schema.nullish
-
-            const hasSelfRef = this.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas })
-            // Inside a getter the getter itself defers evaluation, so suppress
-            // z.lazy() wrapping on nested refs by temporarily clearing cyclicSchemas.
-            // Save before clearing: this.options === options (same reference via definePrinter),
-            // so reading options.cyclicSchemas after mutation would return undefined.
-            const savedCyclicSchemas = this.options.cyclicSchemas
-            if (hasSelfRef) this.options.cyclicSchemas = undefined
-            const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: 'unknown' }))!
-            if (hasSelfRef) this.options.cyclicSchemas = savedCyclicSchemas
-
-            const wrappedOutput = this.options.wrapOutput ? this.options.wrapOutput({ output: baseOutput, schema }) || baseOutput : baseOutput
-
-            const value = applyMiniModifiers({
-              value: wrappedOutput,
-              nullable: isNullable,
-              optional: isOptional,
-              nullish: isNullish,
-              defaultValue: meta.default,
-            })
-
-            if (hasSelfRef) {
-              return `get "${propName}"() { return ${value} }`
-            }
-            return `"${propName}": ${value}`
+        const entries = node.properties.map((prop) => {
+          const { name: propName, schema } = prop
+
+          const meta = ast.syncSchemaRef(schema)
+
+          const isNullable = meta.nullable
+          const isOptional = schema.optional
+          const isNullish = schema.nullish
+
+          const hasSelfRef = this.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas })
+          // Inside a getter the getter itself defers evaluation, so suppress
+          // z.lazy() wrapping on nested refs by temporarily clearing cyclicSchemas.
+          // Save before clearing: this.options === options (same reference via definePrinter),
+          // so reading options.cyclicSchemas after mutation would return undefined.
+          const savedCyclicSchemas = this.options.cyclicSchemas
+          if (hasSelfRef) this.options.cyclicSchemas = undefined
+          const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: 'unknown' }))!
+          if (hasSelfRef) this.options.cyclicSchemas = savedCyclicSchemas
+
+          const wrappedOutput = this.options.wrapOutput ? this.options.wrapOutput({ output: baseOutput, schema }) || baseOutput : baseOutput
+
+          const value = applyMiniModifiers({
+            value: wrappedOutput,
+            nullable: isNullable,
+            optional: isOptional,
+            nullish: isNullish,
+            defaultValue: meta.default,
           })
-          .join(',\n    ')
 
-        return `z.object({\n    ${properties}\n    })`
+          if (hasSelfRef) {
+            return `get ${objectKey(propName)}() { return ${value} }`
+          }
+          return `${objectKey(propName)}: ${value}`
+        })
+
+        return `z.object(${buildObject(entries)})`
       },
       array(node) {
         const items = (node.items ?? []).map((item) => this.transform(item)).filter(Boolean)
@@ -220,7 +218,7 @@ export const printerZodMini = ast.definePrinter<PrinterZodMiniFactory>((options)
       tuple(node) {
         const items = (node.items ?? []).map((item) => this.transform(item)).filter(Boolean)
 
-        return `z.tuple([${items.join(', ')}])`
+        return `z.tuple(${buildList(items)})`
       },
       union(node) {
         const nodeMembers = node.members ?? []
@@ -236,10 +234,10 @@ export const printerZodMini = ast.definePrinter<PrinterZodMiniFactory>((options)
         if (node.discriminatorPropertyName && !nodeMembers.some((m) => m.type === 'intersection')) {
           // z.discriminatedUnion requires ZodObject members; intersections (ZodIntersection) are not
           // assignable to $ZodDiscriminant, so fall back to z.union when any member is an intersection.
-          return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, [${members.join(', ')}])`
+          return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`
         }
 
-        return `z.union([${members.join(', ')}])`
+        return `z.union(${buildList(members)})`
       },
       intersection(node) {
         const members = node.members ?? []

package/src/resolvers/resolverZod.ts

@@ -1,18 +1,20 @@
-import { camelCase, ensureValidVarName, pascalCase } from '@internals/utils'
+import { camelCase, ensureValidVarName, pascalCase, toFilePath } from '@internals/utils'
 import { defineResolver } from '@kubb/core'
 import type { PluginZod } from '../types.ts'
 
 /**
  * Default resolver used by `@kubb/plugin-zod`. Decides the names and file
  * paths for every generated Zod schema. Schemas use camelCase with a
- * `Schema` suffix (`listPetsSchema`); their inferred types use PascalCase.
+ * `Schema` suffix (`listPetsSchema`); their inferred types use PascalCase
+ * with a `SchemaType` suffix (`PetSchemaType`), so the value and the type
+ * never share an identifier even when the schema name is all-uppercase.
  *
  * @example Resolve schema and type names
  * ```ts
  * import { resolverZod } from '@kubb/plugin-zod'
  *
  * resolverZod.default('list pets', 'function') // 'listPetsSchema'
- * resolverZod.resolveSchemaTypeName('pet')     // 'PetSchema'
+ * resolverZod.resolveSchemaTypeName('pet')     // 'PetSchemaType'
  * ```
  */
 export const resolverZod = defineResolver<PluginZod>(() => {
@@ -20,14 +22,14 @@ export const resolverZod = defineResolver<PluginZod>(() => {
     name: 'default',
     pluginName: 'plugin-zod',
     default(name, type) {
-      const resolved = camelCase(name, { isFile: type === 'file', suffix: type ? 'schema' : undefined })
-      return type === 'file' ? resolved : ensureValidVarName(resolved)
+      if (type === 'file') return toFilePath(name, (part) => camelCase(part, { suffix: 'schema' }))
+      return ensureValidVarName(camelCase(name, { suffix: type ? 'schema' : undefined }))
     },
     resolveSchemaName(name) {
       return ensureValidVarName(camelCase(name, { suffix: 'schema' }))
     },
     resolveSchemaTypeName(name) {
-      return ensureValidVarName(pascalCase(name, { suffix: 'schema' }))
+      return ensureValidVarName(pascalCase(name, { suffix: 'schema type' }))
     },
     resolveInputSchemaName(name) {
       return this.resolveSchemaName(`${name} input`)
@@ -36,7 +38,7 @@ export const resolverZod = defineResolver<PluginZod>(() => {
       return this.resolveSchemaTypeName(`${name} input`)
     },
     resolveTypeName(name) {
-      return ensureValidVarName(pascalCase(name))
+      return ensureValidVarName(pascalCase(name, { suffix: 'type' }))
     },
     resolvePathName(name, type) {
       return this.default(name, type)

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
+import type { ast, Exclude, Generator, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
 import type { PrinterZodNodes } from './printers/printerZod.ts'
 import type { PrinterZodMiniNodes } from './printers/printerZodMini.ts'
 
@@ -15,7 +15,7 @@ export type ResolverZod = Resolver &
      * Resolves the schema type name (inferred type from schema).
      *
      * @example Schema type names
-     * `resolver.resolveSchemaTypeName('pet') // → 'Pet'`
+     * `resolver.resolveSchemaTypeName('pet') // → 'PetSchemaType'`
      */
     resolveSchemaTypeName(this: ResolverZod, name: string): string
     /**
@@ -30,14 +30,14 @@ export type ResolverZod = Resolver &
      * Resolves the inferred type name for the request (input) direction variant.
      *
      * @example Input schema type names
-     * `resolver.resolveInputSchemaTypeName('order') // → 'OrderInputSchema'`
+     * `resolver.resolveInputSchemaTypeName('order') // → 'OrderInputSchemaType'`
      */
     resolveInputSchemaTypeName(this: ResolverZod, name: string): string
     /**
      * Resolves the generated type name from the schema.
      *
      * @example Type names
-     * `resolver.resolveTypeName('pet') // → 'Pet'`
+     * `resolver.resolveTypeName('petSchema') // → 'PetSchemaType'`
      */
     resolveTypeName(this: ResolverZod, name: string): string
     /**
@@ -88,17 +88,13 @@ export type ResolverZod = Resolver &
     resolveHeaderParamsName(this: ResolverZod, node: ast.OperationNode, param: ast.ParameterNode): string
   }
 
-export type Options = {
-  /**
-   * Where the generated Zod schemas are written and how they are exported.
-   *
-   * @default { path: 'zod', barrel: { type: 'named' } }
-   */
-  output?: Output
-  /**
-   * Split generated files into subfolders based on the operation's tag.
-   */
-  group?: Group
+/**
+ * Where the generated Zod schemas are written and how they are exported, plus the optional
+ * `group` strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
+ *
+ * @default { path: 'zod', barrel: { type: 'named' } }
+ */
+export type Options = OutputOptions & {
   /**
    * Skip operations matching at least one entry in the list.
    */
@@ -115,7 +111,7 @@ export type Options = {
    * Module specifier used in the `import { z } from '...'` statement.
    * Use `'zod/mini'` for the tree-shakeable bundle.
    *
-   * @default 'zod'
+   * @default mini ? 'zod/mini' : 'zod'
    */
   importPath?: 'zod' | 'zod/mini' | (string & {})
   /**

package/src/utils.ts

@@ -1,4 +1,4 @@
-import { stringify, toRegExpString } from '@internals/utils'
+import { extractRefName, stringify, toRegExpString } from '@kubb/ast/utils'
 import { ast } from '@kubb/core'
 import type { PluginZod, ResolverZod } from './types.ts'
 
@@ -86,7 +86,7 @@ export function containsCodec(node: ast.SchemaNode | undefined, seen: Set<string
 
   if (node.type === 'ref') {
     if (!node.ref) return false
-    const refName = ast.extractRefName(node.ref)
+    const refName = extractRefName(node.ref)
     if (refName) {
       if (seen.has(refName)) return false
       seen.add(refName)