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

package/package.json

@@ -1,20 +1,16 @@
 {
   "name": "@kubb/plugin-zod",
-  "version": "5.0.0-beta.3",
-  "description": "Zod schema generator plugin for Kubb, creating type-safe validation schemas from OpenAPI specifications for runtime data validation.",
+  "version": "5.0.0-beta.30",
+  "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-generator",
+    "code-generation",
     "codegen",
     "kubb",
-    "oas",
     "openapi",
-    "plugins",
+    "parse",
     "runtime-validation",
     "schema",
-    "schema-validation",
     "swagger",
-    "type-safe",
-    "type-safety",
     "typescript",
     "validation",
     "zod"
@@ -30,7 +26,7 @@
     "src",
     "templates",
     "dist",
-    "plugin.json",
+    "extension.yaml",
     "!/**/**.test.**",
     "!/**/__tests__/**",
     "!/**/__snapshots__/**"
@@ -52,15 +48,15 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/core": "5.0.0-beta.3",
-    "@kubb/renderer-jsx": "5.0.0-beta.3",
-    "remeda": "^2.34.0"
+    "@kubb/core": "5.0.0-beta.29",
+    "@kubb/renderer-jsx": "5.0.0-beta.29",
+    "remeda": "^2.34.1"
   },
   "devDependencies": {
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.3"
+    "@kubb/renderer-jsx": "5.0.0-beta.29"
   },
   "size-limit": [
     {

package/src/components/Operations.tsx

@@ -4,11 +4,11 @@ import { Const, File, Type } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 
 type SchemaNames = {
-  request: string | undefined
+  request: string | null
   parameters: {
-    path: string | undefined
-    query: string | undefined
-    header: string | undefined
+    path: string | null
+    query: string | null
+    header: string | null
   }
   responses: { default?: string } & Record<number | string, string>
   errors: Record<number | string, string>

package/src/components/Zod.tsx

@@ -13,7 +13,7 @@ type Props = {
    * then merges in any user-supplied `printer.nodes` overrides.
    */
   printer: ast.Printer<PrinterZodFactory> | ast.Printer<PrinterZodMiniFactory>
-  inferTypeName?: string
+  inferTypeName?: string | null
 }
 
 export function Zod({ name, node, printer, inferTypeName }: Props): KubbReactNode {

package/src/generators/zodGenerator.tsx

@@ -1,18 +1,31 @@
 import type { Adapter } from '@kubb/core'
 import { ast, defineGenerator } from '@kubb/core'
 import type { AdapterOas } from '@kubb/adapter-oas'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
+import { File, jsxRendererSync } from '@kubb/renderer-jsx'
 import { Operations } from '../components/Operations.tsx'
 import { Zod } from '../components/Zod.tsx'
 import { ZOD_NAMESPACE_IMPORTS } from '../constants.ts'
 import { printerZod } from '../printers/printerZod.ts'
 import { printerZodMini } from '../printers/printerZodMini.ts'
-import type { PluginZod } from '../types'
+import type { PluginZod, ResolverZod } from '../types'
 import { buildSchemaNames } from '../utils.ts'
 
+type ZodPrinterEntry = { printer: ReturnType<typeof printerZod>; 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>()
+
+/**
+ * Built-in generator for `@kubb/plugin-zod`. Emits one Zod schema per
+ * schema in the spec plus per-operation request/response/parameter schemas.
+ * When `mini: true`, schemas use the Zod Mini functional API instead of
+ * chainable methods.
+ */
 export const zodGenerator = defineGenerator<PluginZod>({
   name: 'zod',
-  renderer: jsxRenderer,
+  renderer: jsxRendererSync,
   schema(node, ctx) {
     const { adapter, config, resolver, root } = ctx
     const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options
@@ -27,29 +40,45 @@ export const zodGenerator = defineGenerator<PluginZod>({
 
     const imports = adapter.getImports(node, (schemaName) => ({
       name: resolver.resolveSchemaName(schemaName),
-      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }).path,
     }))
 
     const meta = {
       name: resolver.resolveSchemaName(node.name),
-      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
+      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group: group ?? undefined }),
     } as const
 
-    const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : undefined
+    const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : null
 
-    const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : undefined
+    const cyclicSchemas = new Set<string>(ctx.meta.circularNames)
 
-    const schemaPrinter = mini
-      ? printerZodMini({ guidType, wrapOutput, resolver, cyclicSchemas, nodes: printer?.nodes })
-      : printerZod({ coercion, guidType, dateType, wrapOutput, resolver, cyclicSchemas, nodes: printer?.nodes })
+    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
+    }
 
     return (
       <File
         baseName={meta.file.baseName}
         path={meta.file.path}
         meta={meta.file.meta}
-        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
+        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} />)}
@@ -69,24 +98,37 @@ export const zodGenerator = defineGenerator<PluginZod>({
     const params = ast.caseParams(node.parameters, paramsCasing)
 
     const meta = {
-      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
+      file: resolver.resolveFile(
+        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+        { root, output, group: group ?? undefined },
+      ),
     } as const
 
-    const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : undefined
+    const cyclicSchemas = new Set<string>(ctx.meta.circularNames)
 
-    function renderSchemaEntry({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
+    function renderSchemaEntry({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> | null }) {
       if (!schema) return null
 
-      const inferTypeName = inferred ? resolver.resolveTypeName(name) : undefined
+      const inferTypeName = inferred ? resolver.resolveTypeName(name) : null
 
       const imports = adapter.getImports(schema, (schemaName) => ({
         name: resolver.resolveSchemaName(schemaName),
-        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+        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
-        ? printerZodMini({ guidType, wrapOutput, resolver, keysToOmit, cyclicSchemas, nodes: printer?.nodes })
-        : printerZod({ coercion, guidType, dateType, wrapOutput, resolver, keysToOmit, cyclicSchemas, nodes: printer?.nodes })
+        ? keysToOmit?.length
+          ? printerZodMini({ guidType, wrapOutput, resolver, keysToOmit, cyclicSchemas, nodes: printer?.nodes })
+          : cachedMini?.guidType === guidType
+            ? cachedMini.printer
+            : printerZodMini({ guidType, wrapOutput, resolver, 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 })
 
       return (
         <>
@@ -101,13 +143,13 @@ export const zodGenerator = defineGenerator<PluginZod>({
 
     const responseSchemas = node.responses.map((res) =>
       renderSchemaEntry({
-        schema: res.schema,
+        schema: res.content?.[0]?.schema ?? null,
         name: resolver.resolveResponseStatusName(node, res.statusCode),
-        keysToOmit: res.keysToOmit,
+        keysToOmit: res.content?.[0]?.keysToOmit,
       }),
     )
 
-    const responsesWithSchema = node.responses.filter((res) => res.schema)
+    const responsesWithSchema = node.responses.filter((res) => res.content?.[0]?.schema)
     const responseUnionSchema =
       responsesWithSchema.length > 0
         ? (() => {
@@ -118,9 +160,9 @@ export const zodGenerator = defineGenerator<PluginZod>({
             // the response union name, skip generation to avoid redeclaration errors.
             const importedNames = new Set(
               responsesWithSchema.flatMap((res) =>
-                res.schema
+                res.content?.[0]?.schema
                   ? adapter
-                      .getImports(res.schema, (schemaName) => ({
+                      .getImports(res.content[0].schema, (schemaName) => ({
                         name: resolver.resolveSchemaName(schemaName),
                         path: '',
                       }))
@@ -159,8 +201,8 @@ export const zodGenerator = defineGenerator<PluginZod>({
         baseName={meta.file.baseName}
         path={meta.file.path}
         meta={meta.file.meta}
-        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
+        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} />
         {paramSchemas}
@@ -171,7 +213,7 @@ export const zodGenerator = defineGenerator<PluginZod>({
     )
   },
   operations(nodes, ctx) {
-    const { adapter, config, resolver, root } = ctx
+    const { config, resolver, root } = ctx
     const { output, importPath, group, operations, paramsCasing } = ctx.options
 
     if (!operations) {
@@ -180,7 +222,7 @@ export const zodGenerator = defineGenerator<PluginZod>({
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
     const meta = {
-      file: resolver.resolveFile({ name: 'operations', extname: '.ts' }, { root, output, group }),
+      file: resolver.resolveFile({ name: 'operations', extname: '.ts' }, { root, output, group: group ?? undefined }),
     } as const
 
     const transformedOperations = nodes.map((node) => {
@@ -193,8 +235,11 @@ export const zodGenerator = defineGenerator<PluginZod>({
     })
 
     const imports = transformedOperations.flatMap(({ node, data }) => {
-      const names = [data.request, ...Object.values(data.responses), ...Object.values(data.parameters)].filter(Boolean) as string[]
-      const opFile = resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group })
+      const names = [data.request, ...Object.values(data.responses), ...Object.values(data.parameters)].filter(Boolean) as Array<string>
+      const opFile = resolver.resolveFile(
+        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+        { root, output, group: group ?? undefined },
+      )
 
       return names.map((name) => <File.Import key={[name, opFile.path].join('-')} name={[name]} root={meta.file.path} path={opFile.path} />)
     })
@@ -204,8 +249,8 @@ export const zodGenerator = defineGenerator<PluginZod>({
         baseName={meta.file.baseName}
         path={meta.file.path}
         meta={meta.file.meta}
-        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
+        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
       >
         <File.Import isTypeOnly name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
         {imports}

package/src/plugin.ts

@@ -5,20 +5,33 @@ import { resolverZod } from './resolvers/resolverZod.ts'
 import type { PluginZod } from './types.ts'
 
 /**
- * Canonical plugin name for `@kubb/plugin-zod`, used in driver lookups and warnings.
+ * Canonical plugin name for `@kubb/plugin-zod`. Used for driver lookups and
+ * cross-plugin dependency references.
  */
 export const pluginZodName = 'plugin-zod' satisfies PluginZod['name']
 
 /**
- * Generates Zod validation schemas from an OpenAPI specification.
- * Walks schemas and operations, delegates to generators, and writes barrel files
- * based on the configured `barrelType`.
+ * Generates Zod v4 schemas from an OpenAPI spec. Use them to validate API
+ * responses at runtime, build form schemas, or feed back into router libraries
+ * that consume Zod (tRPC, Hono, Elysia). Pair with `@kubb/plugin-client` and
+ * set the client's `parser: 'zod'` to validate every response automatically.
  *
- * @example Zod schema generator
+ * @example
  * ```ts
- * import pluginZod from '@kubb/plugin-zod'
+ * import { defineConfig } from 'kubb'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ * import { pluginZod } from '@kubb/plugin-zod'
+ *
  * export default defineConfig({
- *   plugins: [pluginZod({ output: { path: 'zod' } })]
+ *   input: { path: './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs(),
+ *     pluginZod({
+ *       output: { path: './zod' },
+ *       typed: true,
+ *     }),
+ *   ],
  * })
  * ```
  */
@@ -54,7 +67,7 @@ export const pluginZod = definePlugin<PluginZod>((options) => {
           return `${camelCase(ctx.group)}Controller`
         },
       } satisfies Group)
-    : undefined
+    : null
 
   return {
     name: pluginZodName,

package/src/printers/printerZod.ts

@@ -53,7 +53,7 @@ export type PrinterZodOptions = {
   /**
    * Properties to exclude using `.omit({ key: true })`.
    */
-  keysToOmit?: Array<string>
+  keysToOmit?: Array<string> | null
   /**
    * Schema names that form circular dependency chains.
    * Properties referencing these emit lazy getters wrapping refs in `z.lazy(() => …)`.
@@ -70,6 +70,33 @@ export type PrinterZodOptions = {
  */
 export type PrinterZodFactory = ast.PrinterFactoryOptions<'zod', PrinterZodOptions, string, string>
 
+function strictOneOfMember(member: string, node: ast.SchemaNode): string {
+  if (node.type === 'object' && node.additionalProperties === undefined) {
+    return `${member}.strict()`
+  }
+
+  if (node.type === 'ref') {
+    if (member.startsWith('z.lazy(')) {
+      return member
+    }
+
+    const schema = ast.syncSchemaRef(node)
+
+    if (schema.type === 'object' && (schema.additionalProperties === undefined || schema.additionalProperties === false)) {
+      return `${member}.strict()`
+    }
+  }
+
+  return member
+}
+
+function getMemberConstraint(member: ast.SchemaNode): string | undefined {
+  if (member.primitive === 'string') return lengthConstraints(ast.narrowSchema(member, 'string') ?? {}) || undefined
+  if (member.primitive === 'number' || member.primitive === 'integer')
+    return numberConstraints(ast.narrowSchema(member, 'number') ?? ast.narrowSchema(member, 'integer') ?? {}) || undefined
+  if (member.primitive === 'array') return lengthConstraints(ast.narrowSchema(member, 'array') ?? {}) || undefined
+}
+
 /**
  * Zod v4 printer built with `definePrinter`.
  *
@@ -164,7 +191,7 @@ export const printerZod = ast.definePrinter<PrinterZodFactory>((options) => {
         return `z.enum([${nonNullValues.map(formatLiteral).join(', ')}])`
       },
       ref(node) {
-        if (!node.name) return undefined
+        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
 
@@ -188,19 +215,19 @@ export const printerZod = ast.definePrinter<PrinterZodFactory>((options) => {
             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 = options.cyclicSchemas
+            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.
-            let descriptionToApply = meta.description
-            if (schema.type !== 'ref' && meta.type === 'ref') {
-              descriptionToApply = undefined
-            }
+            const descriptionToApply = schema.type !== 'ref' && meta.type === 'ref' ? undefined : meta.description
 
             const value = applyModifiers({
               value: wrappedOutput,
@@ -218,32 +245,27 @@ export const printerZod = ast.definePrinter<PrinterZodFactory>((options) => {
           })
           .join(',\n    ')
 
-        let result = `z.object({\n    ${properties}\n    })`
+        const objectBase = `z.object({\n    ${properties}\n    })`
 
         // Handle additionalProperties as .catchall() or .strict()
-        if (node.additionalProperties && node.additionalProperties !== true) {
-          const catchallType = this.transform(node.additionalProperties)
-          if (catchallType) {
-            result += `.catchall(${catchallType})`
+        const result = (() => {
+          if (node.additionalProperties && node.additionalProperties !== true) {
+            const catchallType = this.transform(node.additionalProperties)
+            return catchallType ? `${objectBase}.catchall(${catchallType})` : objectBase
           }
-        } else if (node.additionalProperties === true) {
-          result += `.catchall(${this.transform(ast.createSchema({ type: 'unknown' }))})`
-        } else if (node.additionalProperties === false) {
-          result += '.strict()'
-        }
+          if (node.additionalProperties === true) return `${objectBase}.catchall(${this.transform(ast.createSchema({ type: 'unknown' }))})`
+          if (node.additionalProperties === false) return `${objectBase}.strict()`
+          return objectBase
+        })()
 
         return result
       },
       array(node) {
         const items = (node.items ?? []).map((item) => this.transform(item)).filter(Boolean)
         const inner = items.join(', ') || this.transform(ast.createSchema({ type: 'unknown' }))!
-        let result = `z.array(${inner})${lengthConstraints(node)}`
+        const base = `z.array(${inner})${lengthConstraints(node)}`
 
-        if (node.unique) {
-          result += `.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })`
-        }
-
-        return result
+        return node.unique ? `${base}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })` : base
       },
       tuple(node) {
         const items = (node.items ?? []).map((item) => this.transform(item)).filter(Boolean)
@@ -252,7 +274,13 @@ export const printerZod = ast.definePrinter<PrinterZodFactory>((options) => {
       },
       union(node) {
         const nodeMembers = node.members ?? []
-        const members = nodeMembers.map((m) => this.transform(m)).filter(Boolean)
+        const members = nodeMembers
+          .map((memberNode) => {
+            const member = this.transform(memberNode)
+
+            return member && node.strategy === 'one' ? strictOneOfMember(member, memberNode) : member
+          })
+          .filter(Boolean)
         if (members.length === 0) return ''
         if (members.length === 1) return members[0]!
         if (node.discriminatorPropertyName && !nodeMembers.some((m) => m.type === 'intersection')) {
@@ -270,61 +298,37 @@ export const printerZod = ast.definePrinter<PrinterZodFactory>((options) => {
         const [first, ...rest] = members
         if (!first) return ''
 
-        let base = this.transform(first)
-        if (!base) return ''
+        const firstBase = this.transform(first)
+        if (!firstBase) return ''
 
-        for (const member of rest) {
-          if (member.primitive === 'string') {
-            const s = ast.narrowSchema(member, 'string')
-            const c = lengthConstraints(s ?? {})
-            if (c) {
-              base += c
-              continue
-            }
-          } else if (member.primitive === 'number' || member.primitive === 'integer') {
-            const n = ast.narrowSchema(member, 'number') ?? ast.narrowSchema(member, 'integer')
-            const c = numberConstraints(n ?? {})
-            if (c) {
-              base += c
-              continue
-            }
-          } else if (member.primitive === 'array') {
-            const a = ast.narrowSchema(member, 'array')
-            const c = lengthConstraints(a ?? {})
-            if (c) {
-              base += c
-              continue
-            }
-          }
+        return rest.reduce((acc, member) => {
+          const constraint = getMemberConstraint(member)
+          if (constraint) return acc + constraint
           const transformed = this.transform(member)
-          if (transformed) base = `${base}.and(${transformed})`
-        }
-
-        return base
+          return transformed ? `${acc}.and(${transformed})` : acc
+        }, firstBase)
       },
       ...options.nodes,
     },
     print(node) {
       const { keysToOmit } = this.options
 
-      let base = this.transform(node)
-      if (!base) return null
+      const transformed = this.transform(node)
+      if (!transformed) return null
 
       const meta = ast.syncSchemaRef(node)
 
-      if (keysToOmit?.length && meta.primitive === 'object' && !(meta.type === 'union' && meta.discriminatorPropertyName)) {
+      const base = (() => {
+        if (!keysToOmit?.length || meta.primitive !== 'object' || (meta.type === 'union' && meta.discriminatorPropertyName)) return transformed
         // Mirror printerTs `nonNullable: true`: when omitting keys, the resulting
         // schema is a new non-nullable object type — skip optional/nullable/nullish.
         // Discriminated unions (z.discriminatedUnion) do not support .omit(), so skip them.
 
         // If this is a lazy reference, apply omit inside the lazy function
-        const lazyMatch = base.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/)
-        if (lazyMatch) {
-          base = `z.lazy(() => ${lazyMatch[1]}.omit({ ${keysToOmit.map((k: string) => `"${k}": true`).join(', ')} }))`
-        } else {
-          base = `${base}.omit({ ${keysToOmit.map((k: string) => `"${k}": true`).join(', ')} })`
-        }
-      }
+        const lazyMatch = transformed.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/)
+        if (lazyMatch) return `z.lazy(() => ${lazyMatch[1]}.omit({ ${keysToOmit.map((k: string) => `"${k}": true`).join(', ')} }))`
+        return `${transformed}.omit({ ${keysToOmit.map((k: string) => `"${k}": true`).join(', ')} })`
+      })()
 
       return applyModifiers({
         value: base,