@kubb/plugin-zod 5.0.0-beta.30 → 5.0.0-beta.31

package/src/generators/zodGenerator.tsx

@@ -1,3 +1,4 @@
+import { resolveContentTypeVariants } from '@internals/shared'
 import type { Adapter } from '@kubb/core'
 import { ast, defineGenerator } from '@kubb/core'
 import type { AdapterOas } from '@kubb/adapter-oas'
@@ -8,15 +9,43 @@ import { ZOD_NAMESPACE_IMPORTS } from '../constants.ts'
 import { printerZod } from '../printers/printerZod.ts'
 import { printerZodMini } from '../printers/printerZodMini.ts'
 import type { PluginZod, ResolverZod } from '../types'
-import { buildSchemaNames } from '../utils.ts'
+import { buildSchemaNames, containsCodec } from '../utils.ts'
 
-type ZodPrinterEntry = { printer: ReturnType<typeof printerZod>; coercion: unknown; guidType: unknown; dateType: unknown }
+type StdPrinters = { output: ReturnType<typeof printerZod>; input: ReturnType<typeof printerZod> }
+type ZodPrinterEntry = StdPrinters & { coercion: unknown; guidType: unknown; dateType: unknown }
 type ZodMiniPrinterEntry = { printer: ReturnType<typeof printerZodMini>; guidType: unknown }
 
 // Per-build caches: keyed on resolver (unique per plugin instance per build, GC'd when released)
 const zodPrinterCache = new WeakMap<ResolverZod, ZodPrinterEntry>()
 const zodMiniPrinterCache = new WeakMap<ResolverZod, ZodMiniPrinterEntry>()
 
+type StdPrinterParams = { coercion: unknown; guidType: unknown; dateType: unknown; wrapOutput: unknown; cyclicSchemas: ReadonlySet<string>; nodes: unknown }
+
+/**
+ * Returns the cached `output`/`input` direction printers for a resolver, building them on
+ * first use. The `input` printer encodes `Date → string` for request bodies; `output` decodes
+ * `string → Date` for responses. Schemas without `dateType: 'date'` fields print identically.
+ */
+function getStdPrinters(resolver: ResolverZod, params: StdPrinterParams): StdPrinters {
+  const cached = zodPrinterCache.get(resolver)
+  if (cached && cached.coercion === params.coercion && cached.guidType === params.guidType && cached.dateType === params.dateType) {
+    return { output: cached.output, input: cached.input }
+  }
+  const base = { ...params, resolver } as Parameters<typeof printerZod>[0]
+  const output = printerZod({ ...base, direction: 'output' })
+  const input = printerZod({ ...base, direction: 'input' })
+  zodPrinterCache.set(resolver, { output, input, coercion: params.coercion, guidType: params.guidType, dateType: params.dateType })
+  return { output, input }
+}
+
+function getMiniPrinter(resolver: ResolverZod, params: { guidType: unknown; wrapOutput: unknown; cyclicSchemas: ReadonlySet<string>; nodes: unknown }) {
+  const cached = zodMiniPrinterCache.get(resolver)
+  if (cached && cached.guidType === params.guidType) return cached.printer
+  const p = printerZodMini({ ...params, resolver } as Parameters<typeof printerZodMini>[0])
+  zodMiniPrinterCache.set(resolver, { printer: p, guidType: params.guidType })
+  return p
+}
+
 /**
  * Built-in generator for `@kubb/plugin-zod`. Emits one Zod schema per
  * schema in the spec plus per-operation request/response/parameter schemas.
@@ -37,11 +66,36 @@ export const zodGenerator = defineGenerator<PluginZod>({
 
     const mode = ctx.getMode(output)
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
+    const cyclicSchemas = new Set<string>(ctx.meta.circularNames)
+
+    // A codec component is rendered twice: the canonical (output) schema decodes
+    // `string → Date`, and an `${name}InputSchema` variant encodes `Date → string` for requests.
+    const hasCodec = !mini && containsCodec(node)
 
-    const imports = adapter.getImports(node, (schemaName) => ({
+    const codecRefNames = new Set(
+      hasCodec
+        ? ast.collect<string>(node, {
+            schema: (n) => (n.type === 'ref' && n.ref && containsCodec(n) ? (ast.extractRefName(n.ref) ?? undefined) : undefined),
+          })
+        : [],
+    )
+    const importEntries = adapter.getImports(node, (schemaName) => ({
       name: resolver.resolveSchemaName(schemaName),
       path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }).path,
     }))
+    const inputImportEntries = hasCodec
+      ? [...codecRefNames].map((schemaName) => ({
+          name: resolver.resolveInputSchemaName(schemaName),
+          path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }).path,
+        }))
+      : []
+    const seenImports = new Set<string>()
+    const imports = [...importEntries, ...inputImportEntries].filter((imp) => {
+      const key = `${Array.isArray(imp.name) ? imp.name.join(',') : imp.name}|${imp.path}`
+      if (seenImports.has(key)) return false
+      seenImports.add(key)
+      return true
+    })
 
     const meta = {
       name: resolver.resolveSchemaName(node.name),
@@ -50,27 +104,8 @@ export const zodGenerator = defineGenerator<PluginZod>({
 
     const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : null
 
-    const cyclicSchemas = new Set<string>(ctx.meta.circularNames)
-
-    const schemaPrinter = mini ? getCachedMiniPrinter() : getCachedStdPrinter()
-    function getCachedStdPrinter() {
-      const cached = zodPrinterCache.get(resolver)
-      if (cached && cached.coercion === coercion && cached.guidType === guidType && cached.dateType === dateType) {
-        return cached.printer
-      }
-      const p = printerZod({ coercion, guidType, dateType, wrapOutput, resolver, cyclicSchemas, nodes: printer?.nodes })
-      zodPrinterCache.set(resolver, { printer: p, coercion, guidType, dateType })
-      return p
-    }
-    function getCachedMiniPrinter() {
-      const cached = zodMiniPrinterCache.get(resolver)
-      if (cached && cached.guidType === guidType) {
-        return cached.printer
-      }
-      const p = printerZodMini({ guidType, wrapOutput, resolver, cyclicSchemas, nodes: printer?.nodes })
-      zodMiniPrinterCache.set(resolver, { printer: p, guidType })
-      return p
-    }
+    const stdPrinters = mini ? null : getStdPrinters(resolver, { coercion, guidType, dateType, wrapOutput, cyclicSchemas, nodes: printer?.nodes })
+    const schemaPrinter = mini ? getMiniPrinter(resolver, { guidType, wrapOutput, cyclicSchemas, nodes: printer?.nodes }) : stdPrinters!.output
 
     return (
       <File
@@ -81,13 +116,23 @@ 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].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
+        {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} />)}
 
         <Zod name={meta.name} node={node} printer={schemaPrinter} inferTypeName={inferTypeName} />
+        {hasCodec && stdPrinters && (
+          <Zod
+            name={resolver.resolveInputSchemaName(node.name)}
+            node={node}
+            printer={stdPrinters.input}
+            inferTypeName={inferred ? resolver.resolveInputSchemaTypeName(node.name) : null}
+          />
+        )}
       </File>
     )
   },
   operation(node, ctx) {
+    if (!ast.isHttpOperationNode(node)) return null
     const { adapter, config, resolver, root } = ctx
     const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = ctx.options
     const dateType = (adapter as Adapter<AdapterOas>).options.dateType
@@ -106,29 +151,42 @@ export const zodGenerator = defineGenerator<PluginZod>({
 
     const cyclicSchemas = new Set<string>(ctx.meta.circularNames)
 
-    function renderSchemaEntry({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> | null }) {
+    function renderSchemaEntry({
+      schema,
+      name,
+      keysToOmit,
+      direction = 'output',
+    }: {
+      schema: ast.SchemaNode | null
+      name: string
+      keysToOmit?: Array<string> | null
+      direction?: 'input' | 'output'
+    }) {
       if (!schema) return null
 
       const inferTypeName = inferred ? resolver.resolveTypeName(name) : null
 
+      // In the input direction, refs to codec components resolve to their input variant.
+      const codecRefNames =
+        direction === 'input' && !mini
+          ? new Set(
+              ast.collect<string>(schema, {
+                schema: (n) => (n.type === 'ref' && n.ref && containsCodec(n) ? (ast.extractRefName(n.ref) ?? undefined) : undefined),
+              }),
+            )
+          : null
       const imports = adapter.getImports(schema, (schemaName) => ({
-        name: resolver.resolveSchemaName(schemaName),
+        name: codecRefNames?.has(schemaName) ? resolver.resolveInputSchemaName(schemaName) : resolver.resolveSchemaName(schemaName),
         path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }).path,
       }))
 
-      const cachedStd = zodPrinterCache.get(resolver)
-      const cachedMini = zodMiniPrinterCache.get(resolver)
       const schemaPrinter = mini
         ? keysToOmit?.length
           ? printerZodMini({ guidType, wrapOutput, resolver, keysToOmit, cyclicSchemas, nodes: printer?.nodes })
-          : cachedMini?.guidType === guidType
-            ? cachedMini.printer
-            : printerZodMini({ guidType, wrapOutput, resolver, cyclicSchemas, nodes: printer?.nodes })
+          : getMiniPrinter(resolver, { guidType, wrapOutput, cyclicSchemas, nodes: printer?.nodes })
         : keysToOmit?.length
-          ? printerZod({ coercion, guidType, dateType, wrapOutput, resolver, keysToOmit, cyclicSchemas, nodes: printer?.nodes })
-          : cachedStd?.coercion === coercion && cachedStd?.guidType === guidType && cachedStd?.dateType === dateType
-            ? cachedStd.printer
-            : printerZod({ coercion, guidType, dateType, wrapOutput, resolver, cyclicSchemas, nodes: printer?.nodes })
+          ? printerZod({ coercion, guidType, dateType, wrapOutput, resolver, keysToOmit, cyclicSchemas, nodes: printer?.nodes, direction })
+          : getStdPrinters(resolver, { coercion, guidType, dateType, wrapOutput, cyclicSchemas, nodes: printer?.nodes })[direction]
 
       return (
         <>
@@ -139,17 +197,49 @@ export const zodGenerator = defineGenerator<PluginZod>({
       )
     }
 
-    const paramSchemas = params.map((param) => renderSchemaEntry({ schema: param.schema, name: resolver.resolveParamName(node, param) }))
+    // Multiple content types for a single name — emit one schema per content type plus a union alias.
+    function buildContentTypeVariants(
+      entries: Array<{ contentType: string; schema?: ast.SchemaNode | null; keysToOmit?: Array<string> | null }>,
+      baseName: string,
+      decorate?: (schema: ast.SchemaNode) => ast.SchemaNode,
+      direction?: 'input' | 'output',
+    ) {
+      const variants = resolveContentTypeVariants(entries, baseName)
+      const unionSchema = ast.createSchema({
+        type: 'union',
+        members: variants.map((variant) => ast.createSchema({ type: 'ref', name: variant.name })),
+      })
+      return (
+        <>
+          {variants.map((variant) =>
+            renderSchemaEntry({
+              schema: decorate ? decorate(variant.schema) : variant.schema,
+              name: variant.name,
+              keysToOmit: variant.keysToOmit,
+              direction,
+            }),
+          )}
+          {renderSchemaEntry({ schema: unionSchema, name: baseName, direction })}
+        </>
+      )
+    }
 
-    const responseSchemas = node.responses.map((res) =>
-      renderSchemaEntry({
-        schema: res.content?.[0]?.schema ?? null,
+    const paramSchemas = params.map((param) => renderSchemaEntry({ schema: param.schema, name: resolver.resolveParamName(node, param), direction: 'input' }))
+
+    const responseSchemas = node.responses.map((res) => {
+      const variants = (res.content ?? []).filter((entry) => entry.schema)
+      if (variants.length > 1) {
+        return buildContentTypeVariants(res.content!, resolver.resolveResponseStatusName(node, res.statusCode))
+      }
+      const primary = variants[0] ?? res.content?.[0]
+      return renderSchemaEntry({
+        schema: primary?.schema ?? null,
         name: resolver.resolveResponseStatusName(node, res.statusCode),
-        keysToOmit: res.content?.[0]?.keysToOmit,
-      }),
-    )
+        keysToOmit: primary?.keysToOmit,
+      })
+    })
 
-    const responsesWithSchema = node.responses.filter((res) => res.content?.[0]?.schema)
+    const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema))
     const responseUnionSchema =
       responsesWithSchema.length > 0
         ? (() => {
@@ -160,14 +250,16 @@ export const zodGenerator = defineGenerator<PluginZod>({
             // the response union name, skip generation to avoid redeclaration errors.
             const importedNames = new Set(
               responsesWithSchema.flatMap((res) =>
-                res.content?.[0]?.schema
-                  ? adapter
-                      .getImports(res.content[0].schema, (schemaName) => ({
-                        name: resolver.resolveSchemaName(schemaName),
-                        path: '',
-                      }))
-                      .flatMap((imp) => (Array.isArray(imp.name) ? imp.name : [imp.name]))
-                  : [],
+                (res.content ?? []).flatMap((entry) =>
+                  entry.schema
+                    ? adapter
+                        .getImports(entry.schema, (schemaName) => ({
+                          name: resolver.resolveSchemaName(schemaName),
+                          path: '',
+                        }))
+                        .flatMap((imp) => (Array.isArray(imp.name) ? imp.name : [imp.name]))
+                    : [],
+                ),
               ),
             )
 
@@ -185,16 +277,29 @@ export const zodGenerator = defineGenerator<PluginZod>({
           })()
         : null
 
-    const requestSchema = node.requestBody?.content?.[0]?.schema
-      ? renderSchemaEntry({
-          schema: {
-            ...node.requestBody.content![0]!.schema!,
-            description: node.requestBody.description ?? node.requestBody.content![0]!.schema!.description,
-          },
+    const requestBodyContent = node.requestBody?.content ?? []
+    const requestSchema = (() => {
+      if (requestBodyContent.length === 0) return null
+      if (requestBodyContent.length === 1) {
+        const entry = requestBodyContent[0]!
+        if (!entry.schema) return null
+        return renderSchemaEntry({
+          schema: { ...entry.schema, description: node.requestBody!.description ?? entry.schema.description },
           name: resolver.resolveDataName(node),
-          keysToOmit: node.requestBody.content![0]!.keysToOmit,
+          keysToOmit: entry.keysToOmit,
+          direction: 'input',
         })
-      : null
+      }
+      return buildContentTypeVariants(
+        requestBodyContent,
+        resolver.resolveDataName(node),
+        (schema) => ({
+          ...schema,
+          description: node.requestBody!.description ?? schema.description,
+        }),
+        'input',
+      )
+    })()
 
     return (
       <File
@@ -225,7 +330,7 @@ export const zodGenerator = defineGenerator<PluginZod>({
       file: resolver.resolveFile({ name: 'operations', extname: '.ts' }, { root, output, group: group ?? undefined }),
     } as const
 
-    const transformedOperations = nodes.map((node) => {
+    const transformedOperations = nodes.filter(ast.isHttpOperationNode).map((node) => {
       const params = ast.caseParams(node.parameters, paramsCasing)
 
       return {

package/src/plugin.ts

@@ -1,5 +1,5 @@
-import { camelCase } from '@internals/utils'
-import { definePlugin, type Group } from '@kubb/core'
+import { createGroupConfig } from '@internals/shared'
+import { definePlugin } from '@kubb/core'
 import { zodGenerator } from './generators/zodGenerator.tsx'
 import { resolverZod } from './resolvers/resolverZod.ts'
 import type { PluginZod } from './types.ts'
@@ -57,17 +57,7 @@ export const pluginZod = definePlugin<PluginZod>((options) => {
     generators: userGenerators = [],
   } = options
 
-  const groupConfig = group
-    ? ({
-        ...group,
-        name: (ctx) => {
-          if (group.type === 'path') {
-            return `${ctx.group.split('/')[1]}`
-          }
-          return `${camelCase(ctx.group)}Controller`
-        },
-      } satisfies Group)
-    : null
+  const groupConfig = createGroupConfig(group, { suffix: 'Controller' })
 
   return {
     name: pluginZodName,

package/src/printers/printerZod.ts

@@ -2,7 +2,7 @@ import { stringify } from '@internals/utils'
 
 import { ast } from '@kubb/core'
 import type { PluginZod, ResolverZod } from '../types.ts'
-import { applyModifiers, formatLiteral, lengthConstraints, numberConstraints, shouldCoerce } from '../utils.ts'
+import { applyModifiers, containsCodec, formatLiteral, getCodec, lengthConstraints, numberConstraints, shouldCoerce } from '../utils.ts'
 import type { AdapterOas } from '@kubb/adapter-oas'
 
 /**
@@ -59,6 +59,15 @@ export type PrinterZodOptions = {
    * Properties referencing these emit lazy getters wrapping refs in `z.lazy(() => …)`.
    */
   cyclicSchemas?: ReadonlySet<string>
+  /**
+   * Print direction for `dateType: 'date'` fields (`Date` in TypeScript):
+   * - `'output'` (default) — decode the wire `string` into a `Date` (response bodies).
+   * - `'input'` — encode a `Date` back into the wire `string` (request bodies/params).
+   *
+   * Diverging the directions requires the generator to emit an `${name}InputSchema`
+   * variant for each date-bearing component.
+   */
+  direction?: 'input' | 'output'
   /**
    * Custom handler map for node type overrides.
    */
@@ -139,11 +148,13 @@ export const printerZod = ast.definePrinter<PrinterZodFactory>((options) => {
         return shouldCoerce(this.options.coercion, 'numbers') ? 'z.coerce.bigint()' : 'z.bigint()'
       },
       date(node) {
-        if (node.representation === 'string') {
-          return 'z.iso.date()'
+        // representation: 'date' → typed as `Date`; decode/encode at the boundary.
+        const codec = getCodec(node)
+        if (codec) {
+          return this.options.direction === 'input' ? codec.encode(node) : codec.decode(node)
         }
 
-        return shouldCoerce(this.options.coercion, 'dates') ? 'z.coerce.date()' : 'z.date()'
+        return 'z.iso.date()'
       },
       datetime(node) {
         const offset = node.offset || this.options.dateType === 'stringOffset'
@@ -193,7 +204,15 @@ 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 resolvedName = node.ref ? (this.options.resolver?.default(refName, 'function') ?? refName) : 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.
+        const useInputVariant = node.ref != null && this.options.direction === 'input' && containsCodec(node)
+        const resolvedName = node.ref
+          ? useInputVariant
+            ? (this.options.resolver?.resolveInputSchemaName(refName) ?? refName)
+            : (this.options.resolver?.default(refName, 'function') ?? refName)
+          : node.name
 
         if (node.ref && this.options.cyclicSchemas?.has(refName)) {
           return `z.lazy(() => ${resolvedName})`

package/src/resolvers/resolverZod.ts

@@ -29,6 +29,12 @@ export const resolverZod = defineResolver<PluginZod>(() => {
     resolveSchemaTypeName(name) {
       return ensureValidVarName(pascalCase(name, { suffix: 'schema' }))
     },
+    resolveInputSchemaName(name) {
+      return this.resolveSchemaName(`${name} input`)
+    },
+    resolveInputSchemaTypeName(name) {
+      return this.resolveSchemaTypeName(`${name} input`)
+    },
     resolveTypeName(name) {
       return ensureValidVarName(pascalCase(name))
     },

package/src/types.ts

@@ -18,6 +18,21 @@ export type ResolverZod = Resolver &
      * `resolver.resolveSchemaTypeName('pet') // → 'Pet'`
      */
     resolveSchemaTypeName(this: ResolverZod, name: string): string
+    /**
+     * Resolves the schema function name for the request (input) direction of a
+     * date-bearing component, where `Date` is encoded back to a wire `string`.
+     *
+     * @example Input schema names
+     * `resolver.resolveInputSchemaName('order') // → 'orderInputSchema'`
+     */
+    resolveInputSchemaName(this: ResolverZod, name: string): string
+    /**
+     * Resolves the inferred type name for the request (input) direction variant.
+     *
+     * @example Input schema type names
+     * `resolver.resolveInputSchemaTypeName('order') // → 'OrderInputSchema'`
+     */
+    resolveInputSchemaTypeName(this: ResolverZod, name: string): string
     /**
      * Resolves the generated type name from the schema.
      *

package/src/utils.ts

@@ -12,6 +12,99 @@ export function shouldCoerce(coercion: PluginZod['resolvedOptions']['coercion']
   return !!coercion[type]
 }
 
+/**
+ * A codec for a schema node whose runtime type differs from its JSON wire type:
+ * the output (response) schema decodes wire → runtime, and the input (request)
+ * variant encodes runtime → wire.
+ *
+ * To support another codec type, append a `Codec` to `codecs` and route that
+ * type's printer node handler through `getCodec`.
+ */
+export type Codec = {
+  /**
+   * Whether this node is encoded/decoded by this codec.
+   */
+  matches(node: ast.SchemaNode): boolean
+  /**
+   * Output direction (response): decode the wire value into the runtime type.
+   */
+  decode(node: ast.SchemaNode): string
+  /**
+   * Input direction (request): encode the runtime value back to the wire value.
+   */
+  encode(node: ast.SchemaNode): string
+}
+
+/**
+ * `dateType: 'date'` fields are typed as `Date` but travel as ISO `string`s.
+ * Output decodes `string → Date`; input encodes `Date → string`, preserving the
+ * `date` (`YYYY-MM-DD`) vs `date-time` precision carried on `node.format`.
+ */
+const dateCodec: Codec = {
+  matches(node) {
+    return node.type === 'date' && node.representation === 'date'
+  },
+  decode(node) {
+    return node.format === 'date' ? 'z.iso.date().transform((value) => new Date(value))' : 'z.iso.datetime().transform((value) => new Date(value))'
+  },
+  encode(node) {
+    return node.format === 'date' ? 'z.date().transform((value) => value.toISOString().slice(0, 10))' : 'z.date().transform((value) => value.toISOString())'
+  },
+}
+
+/**
+ * Registered codecs, checked in order.
+ */
+const codecs: Array<Codec> = [dateCodec]
+
+/**
+ * Returns the codec for this node, or `undefined` when the node needs no
+ * encode/decode (its wire and runtime types match).
+ */
+export function getCodec(node: ast.SchemaNode | undefined): Codec | undefined {
+  if (!node) return undefined
+  return codecs.find((codec) => codec.matches(node))
+}
+
+/**
+ * Returns `true` when the node itself is encoded/decoded by a codec.
+ */
+export function hasCodec(node: ast.SchemaNode | undefined): boolean {
+  return getCodec(node) !== undefined
+}
+
+/**
+ * Returns `true` when the schema transitively contains a codec node —
+ * a value whose runtime type differs from its wire type (see {@link hasCodec}),
+ * so it must be decoded (response) or encoded (request) at the validation boundary.
+ * `$ref`s are followed via their resolved schema; a `seen` set guards cycles.
+ */
+export function containsCodec(node: ast.SchemaNode | undefined, seen: Set<string> = new Set()): boolean {
+  if (!node) return false
+
+  if (hasCodec(node)) return true
+
+  if (node.type === 'ref') {
+    if (!node.ref) return false
+    const refName = ast.extractRefName(node.ref)
+    if (refName) {
+      if (seen.has(refName)) return false
+      seen.add(refName)
+    }
+    const resolved = ast.syncSchemaRef(node)
+    if (resolved.type === 'ref') return false
+    return containsCodec(resolved, seen)
+  }
+
+  const children: Array<ast.SchemaNode | undefined> = []
+  if ('properties' in node && node.properties) children.push(...node.properties.map((prop) => prop.schema))
+  if ('items' in node && node.items) children.push(...node.items)
+  if ('members' in node && node.members) children.push(...node.members)
+  if ('additionalProperties' in node && node.additionalProperties && node.additionalProperties !== true) children.push(node.additionalProperties)
+
+  return children.some((child) => containsCodec(child, seen))
+}
+
 /**
  * Collects all resolved schema names for an operation's parameters and responses
  * into a single lookup object, useful for building imports and type references.