@kubb/ast 5.0.0-beta.61 → 5.0.0-beta.63

package/src/nodes/file.ts

@@ -1,4 +1,9 @@
-import { defineNode } from '../node.ts'
+import { hash } from 'node:crypto'
+import path from 'node:path'
+import { trimExtName } from '@internals/utils'
+import { defineNode } from '../defineNode.ts'
+import { extractStringsFromNodes } from '../utils/extractStringsFromNodes.ts'
+import { combineExports, combineImports, combineSources } from '../utils/fileMerge.ts'
 import type { BaseNode } from './base.ts'
 import type { CodeNode } from './code.ts'
 
@@ -192,13 +197,14 @@ export type FileNode<TMeta extends object = object> = BaseNode & {
   id: string
   /**
    * File name without extension, derived from `baseName`.
-   * @link https://nodejs.org/api/path.html#pathformatpathobject
+   *
+   * @see https://nodejs.org/api/path.html#pathformatpathobject
    */
   name: string
   /**
-   * File base name, including extension.
-   * Based on UNIX basename: `${name}${extname}`
-   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+   * File base name, including extension, shaped like `${name}${extname}`.
+   *
+   * @see https://nodejs.org/api/path.html#pathbasenamepath-suffix
    */
   baseName: `${string}.${string}`
   /**
@@ -242,6 +248,22 @@ export type FileNode<TMeta extends object = object> = BaseNode & {
  */
 export const importDef = defineNode<ImportNode>({ kind: 'Import' })
 
+/**
+ * Definition for the {@link ExportNode}.
+ */
+export const exportDef = defineNode<ExportNode>({ kind: 'Export' })
+
+/**
+ * Definition for the {@link SourceNode}.
+ */
+export const sourceDef = defineNode<SourceNode>({ kind: 'Source' })
+
+/**
+ * Definition for the {@link FileNode}. The fully resolved builder lives in
+ * `createFile`, so this definition only supplies the guard.
+ */
+export const fileDef = defineNode<FileNode>({ kind: 'File' })
+
 /**
  * Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
  *
@@ -253,11 +275,6 @@ export const importDef = defineNode<ImportNode>({ kind: 'Import' })
  */
 export const createImport = importDef.create
 
-/**
- * Definition for the {@link ExportNode}.
- */
-export const exportDef = defineNode<ExportNode>({ kind: 'Export' })
-
 /**
  * Creates an `ExportNode` representing a language-agnostic export/public API declaration.
  *
@@ -269,11 +286,6 @@ export const exportDef = defineNode<ExportNode>({ kind: 'Export' })
  */
 export const createExport = exportDef.create
 
-/**
- * Definition for the {@link SourceNode}.
- */
-export const sourceDef = defineNode<SourceNode>({ kind: 'Source' })
-
 /**
  * Creates a `SourceNode` representing a fragment of source code within a file.
  *
@@ -285,7 +297,84 @@ export const sourceDef = defineNode<SourceNode>({ kind: 'Source' })
 export const createSource = sourceDef.create
 
 /**
- * Definition for the {@link FileNode}. The fully resolved builder lives in
- * `createFile`, so this definition only supplies the guard.
+ * Input descriptor for {@link createFile}, before `id`, `name`, and `extname` are computed
+ * and `imports`/`exports`/`sources` are deduplicated.
  */
-export const fileDef = defineNode<FileNode>({ kind: 'File' })
+export type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind' | 'id' | 'name' | 'extname' | 'imports' | 'exports' | 'sources'> &
+  Pick<Partial<FileNode<TMeta>>, 'imports' | 'exports' | 'sources'>
+
+/**
+ * Creates a fully resolved `FileNode` from a file input descriptor.
+ *
+ * Computes:
+ * - `id` SHA256 hash of the file path
+ * - `name` `baseName` without extension
+ * - `extname` extension extracted from `baseName`
+ *
+ * Deduplicates:
+ * - `sources` via `combineSources`
+ * - `exports` via `combineExports`
+ * - `imports` via `combineImports` (also filters unused imports)
+ *
+ * @throws {Error} when `baseName` has no extension.
+ *
+ * @example
+ * ```ts
+ * const file = createFile({
+ *   baseName: 'petStore.ts',
+ *   path: 'src/models/petStore.ts',
+ *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
+ *   imports: [createImport({ name: ['z'], path: 'zod' })],
+ *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+ * })
+ * // file.id      = SHA256 hash of 'src/models/petStore.ts'
+ * // file.name    = 'petStore'
+ * // file.extname = '.ts'
+ * ```
+ */
+export function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta> {
+  const rawExtname = path.extname(input.baseName)
+  // Handle dotfile basename like '.ts' where path.extname returns ''
+  const extname = (rawExtname || (input.baseName.startsWith('.') ? input.baseName : '')) as `.${string}`
+  if (!extname) {
+    throw new Error(`No extname found for ${input.baseName}`)
+  }
+
+  const source = (input.sources ?? [])
+    .flatMap((item) => item.nodes ?? [])
+    .map((node) => extractStringsFromNodes([node]))
+    .filter(Boolean)
+    .join('\n\n')
+  const resolvedExports = input.exports?.length ? combineExports(input.exports) : []
+  const combinedImports = input.imports?.length ? combineImports(input.imports, resolvedExports, source || undefined) : []
+  const localNames = new Set((input.sources ?? []).map((item) => item.name).filter((name): name is string => Boolean(name)))
+  const nameOf = (item: string | { propertyName: string; name?: string }): string => (typeof item === 'string' ? item : (item.name ?? item.propertyName))
+  // Drop self-imports. Consolidating output (`mode: 'file'`) can place a symbol's
+  // definition and a cross-file import of it in the same file. The first pass catches imports that
+  // resolve to this file's own path. The second drops imports of names the file already defines,
+  // the case consolidation produces when the import path no longer matches `input.path`. Sources
+  // stay intact, so the local definition remains. Bare specifiers like `'zod'` never match a path.
+  const resolvedImports = combinedImports
+    .filter((imp) => imp.path !== input.path)
+    .flatMap((imp) => {
+      if (!Array.isArray(imp.name)) {
+        return typeof imp.name === 'string' && localNames.has(imp.name) ? [] : [imp]
+      }
+      const kept = imp.name.filter((item) => !localNames.has(nameOf(item)))
+      if (!kept.length) return []
+      return [kept.length === imp.name.length ? imp : { ...imp, name: kept }]
+    })
+  const resolvedSources = input.sources?.length ? combineSources(input.sources) : []
+
+  return {
+    kind: 'File',
+    ...input,
+    id: hash('sha256', input.path, 'hex'),
+    name: trimExtName(input.baseName),
+    extname,
+    imports: resolvedImports,
+    exports: resolvedExports,
+    sources: resolvedSources,
+    meta: input.meta ?? ({} as TMeta),
+  }
+}

package/src/nodes/function.ts

@@ -1,4 +1,4 @@
-import { defineNode } from '../node.ts'
+import { defineNode } from '../defineNode.ts'
 import type { BaseNode } from './base.ts'
 
 /**
@@ -43,11 +43,11 @@ export type TypeLiteralNode = BaseNode & {
 
 /**
  * AST node for a single field accessed from a named group type.
- * TypeScript renders as `objectType['indexType']`.
+ * TypeScript renders as `target['key']`.
  *
  * @example
  * ```ts
- * createIndexedAccessType({ objectType: 'GetPetPathParams', indexType: 'petId' })
+ * createIndexedAccessType({ target: 'GetPetPathParams', key: 'petId' })
  * // GetPetPathParams['petId']
  * ```
  */
@@ -56,11 +56,11 @@ export type IndexedAccessTypeNode = BaseNode & {
   /**
    * Name of the type being indexed, e.g. `'GetPetPathParams'`.
    */
-  objectType: string
+  target: string
   /**
    * Field key to access, e.g. `'petId'`.
    */
-  indexType: string
+  key: string
 }
 
 /**
@@ -168,49 +168,16 @@ export type FunctionParamKind = FunctionParamNode['kind']
  */
 export const typeLiteralDef = defineNode<TypeLiteralNode, Pick<TypeLiteralNode, 'members'>>({ kind: 'TypeLiteral' })
 
-/**
- * Creates a {@link TypeLiteralNode} representing an inline anonymous object type.
- *
- * @example
- * ```ts
- * createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
- * // { petId: string }
- * ```
- */
-export const createTypeLiteral = typeLiteralDef.create
-
 /**
  * Definition for the {@link IndexedAccessTypeNode}.
  */
 export const indexedAccessTypeDef = defineNode<IndexedAccessTypeNode, Omit<IndexedAccessTypeNode, 'kind'>>({ kind: 'IndexedAccessType' })
 
-/**
- * Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
- *
- * @example
- * ```ts
- * createIndexedAccessType({ objectType: 'DeletePetPathParams', indexType: 'petId' })
- * // DeletePetPathParams['petId']
- * ```
- */
-export const createIndexedAccessType = indexedAccessTypeDef.create
-
 /**
  * Definition for the {@link ObjectBindingPatternNode}.
  */
 export const objectBindingPatternDef = defineNode<ObjectBindingPatternNode, Pick<ObjectBindingPatternNode, 'elements'>>({ kind: 'ObjectBindingPattern' })
 
-/**
- * Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
- *
- * @example
- * ```ts
- * createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
- * // { id, name }
- * ```
- */
-export const createObjectBindingPattern = objectBindingPatternDef.create
-
 /**
  * Plain property descriptor for a destructured group built by {@link createFunctionParameter}.
  */
@@ -244,6 +211,47 @@ export const functionParameterDef = defineNode<FunctionParameterNode, FunctionPa
   },
 })
 
+/**
+ * Definition for the {@link FunctionParametersNode}.
+ */
+export const functionParametersDef = defineNode<FunctionParametersNode, Partial<Omit<FunctionParametersNode, 'kind'>>>({
+  kind: 'FunctionParameters',
+  defaults: { params: [] },
+})
+
+/**
+ * Creates a {@link TypeLiteralNode} representing an inline anonymous object type.
+ *
+ * @example
+ * ```ts
+ * createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
+ * // { petId: string }
+ * ```
+ */
+export const createTypeLiteral = typeLiteralDef.create
+
+/**
+ * Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
+ *
+ * @example
+ * ```ts
+ * createIndexedAccessType({ target: 'DeletePetPathParams', key: 'petId' })
+ * // DeletePetPathParams['petId']
+ * ```
+ */
+export const createIndexedAccessType = indexedAccessTypeDef.create
+
+/**
+ * Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
+ *
+ * @example
+ * ```ts
+ * createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+ * // { id, name }
+ * ```
+ */
+export const createObjectBindingPattern = objectBindingPatternDef.create
+
 /**
  * Creates a `FunctionParameterNode`. `optional` defaults to `false`.
  *
@@ -261,14 +269,6 @@ export const functionParameterDef = defineNode<FunctionParameterNode, FunctionPa
  */
 export const createFunctionParameter = functionParameterDef.create
 
-/**
- * Definition for the {@link FunctionParametersNode}.
- */
-export const functionParametersDef = defineNode<FunctionParametersNode, Partial<Omit<FunctionParametersNode, 'kind'>>>({
-  kind: 'FunctionParameters',
-  defaults: { params: [] },
-})
-
 /**
  * Creates a `FunctionParametersNode` from an ordered list of parameters.
  *

package/src/nodes/index.ts

@@ -14,7 +14,7 @@ import type { SchemaNode } from './schema.ts'
 export type { NodeKind } from './base.ts'
 export type { ArrowFunctionNode, BreakNode, CodeNode, ConstNode, FunctionNode, JSDocNode, JsxNode, TextNode, TypeNode } from './code.ts'
 export type { ContentNode } from './content.ts'
-export type { ExportNode, FileNode, ImportNode, SourceNode } from './file.ts'
+export type { ExportNode, FileNode, ImportNode, SourceNode, UserFileNode } from './file.ts'
 export type {
   FunctionParamKind,
   FunctionParameterNode,
@@ -25,14 +25,13 @@ export type {
   TypeExpression,
   TypeLiteralNode,
 } from './function.ts'
-export type { StatusCode } from './http.ts'
 export type { InputMeta, InputNode } from './input.ts'
 export type { GenericOperationNode, HttpMethod, HttpOperationNode, OperationNode } from './operation.ts'
 export type { OutputNode } from './output.ts'
 export type { ParameterLocation, ParameterNode } from './parameter.ts'
 export type { PropertyNode } from './property.ts'
 export type { RequestBodyNode } from './requestBody.ts'
-export type { ResponseNode } from './response.ts'
+export type { ResponseNode, StatusCode } from './response.ts'
 export type {
   ArraySchemaNode,
   DateSchemaNode,

package/src/nodes/input.ts

@@ -1,5 +1,5 @@
 import type { Streamable } from '@internals/utils'
-import { defineNode } from '../node.ts'
+import { defineNode } from '../defineNode.ts'
 import type { BaseNode } from './base.ts'
 import type { OperationNode } from './operation.ts'
 import type { SchemaNode } from './schema.ts'
@@ -68,8 +68,7 @@ export type InputMeta = {
  * Produced by the adapter and consumed by all Kubb plugins.
  *
  * `Stream` switches `schemas` and `operations` between eager `Array`s (the default) and lazy
- * `AsyncIterable`s. The streaming variant `InputNode<true>` yields nodes one at a time and makes
- * `meta` optional, since the adapter can emit metadata before the first node is parsed.
+ * `AsyncIterable`s. The streaming variant `InputNode<true>` yields nodes one at a time.
  *
  * @example
  * ```ts
@@ -101,7 +100,11 @@ export type InputNode<Stream extends boolean = false> = BaseNode & {
    * All operation nodes in the document.
    */
   operations: Streamable<OperationNode, Stream>
-} & (Stream extends true ? { meta?: InputMeta } : { meta: InputMeta })
+  /**
+   * Document metadata populated by the adapter.
+   */
+  meta: InputMeta
+}
 
 /**
  * Definition for the {@link InputNode}.
@@ -115,8 +118,8 @@ export const inputDef = defineNode<InputNode, Partial<Omit<InputNode, 'kind'>>>(
 
 /**
  * Creates an `InputNode`. Pass `stream: true` for the streaming variant whose `schemas` and
- * `operations` are `AsyncIterable` sources and whose `meta` is optional. Otherwise it builds the
- * eager variant with array `schemas`/`operations` and the defaulted `meta`.
+ * `operations` are `AsyncIterable` sources. Otherwise it builds the eager variant with array
+ * `schemas`/`operations`. Both variants get the defaulted `meta`.
  *
  * @example Eager
  * ```ts
@@ -131,10 +134,11 @@ export const inputDef = defineNode<InputNode, Partial<Omit<InputNode, 'kind'>>>(
  */
 export function createInput<Stream extends boolean = false>(options: Partial<Omit<InputNode<Stream>, 'kind'>> & { stream?: Stream } = {}): InputNode<Stream> {
   const { stream, ...overrides } = options
-  // Streaming inputs carry AsyncIterable sources, so skip the array/meta defaults that
-  // inputDef.create applies for the eager variant.
+  // Streaming inputs carry AsyncIterable sources, so skip the array defaults that
+  // inputDef.create applies for the eager variant. Keep the meta default.
   if (stream) {
-    return { kind: 'Input', ...overrides } as InputNode<Stream>
+    return { kind: 'Input', meta: { circularNames: [], enumNames: [] }, ...overrides } as InputNode<Stream>
   }
+
   return inputDef.create(overrides as Partial<Omit<InputNode, 'kind'>>) as InputNode<Stream>
 }

package/src/nodes/operation.ts

@@ -1,9 +1,12 @@
-import { defineNode } from '../node.ts'
+import { defineNode } from '../defineNode.ts'
 import type { BaseNode } from './base.ts'
 import type { ParameterNode } from './parameter.ts'
-import { createRequestBody, type RequestBodyNode, type UserRequestBody } from './requestBody.ts'
+import { createRequestBody, type RequestBodyNode } from './requestBody.ts'
 import type { ResponseNode } from './response.ts'
 
+/**
+ * HTTP method an operation responds to.
+ */
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE'
 
 /**
@@ -111,7 +114,7 @@ type OperationInput = {
   operationId: string
   method?: HttpOperationNode['method']
   path?: HttpOperationNode['path']
-  requestBody?: UserRequestBody
+  requestBody?: Omit<RequestBodyNode, 'kind'>
   [key: string]: unknown
 }
 
@@ -151,13 +154,13 @@ export const operationDef = defineNode<OperationNode, OperationInput>({
 export function createOperation(
   props: Pick<HttpOperationNode, 'operationId' | 'method' | 'path'> &
     Partial<Omit<HttpOperationNode, 'kind' | 'operationId' | 'method' | 'path' | 'requestBody'>> & {
-      requestBody?: UserRequestBody
+      requestBody?: Omit<RequestBodyNode, 'kind'>
     },
 ): HttpOperationNode
 export function createOperation(
   props: Pick<GenericOperationNode, 'operationId'> &
     Partial<Omit<GenericOperationNode, 'kind' | 'operationId' | 'requestBody'>> & {
-      requestBody?: UserRequestBody
+      requestBody?: Omit<RequestBodyNode, 'kind'>
     },
 ): GenericOperationNode
 export function createOperation(props: OperationInput): OperationNode {

package/src/nodes/output.ts

@@ -1,4 +1,4 @@
-import { defineNode } from '../node.ts'
+import { defineNode } from '../defineNode.ts'
 import type { BaseNode } from './base.ts'
 import type { FileNode } from './file.ts'
 

package/src/nodes/parameter.ts

@@ -1,4 +1,5 @@
-import { defineNode, syncOptionality } from '../node.ts'
+import { defineNode } from '../defineNode.ts'
+import { optionality } from '../optionality.ts'
 import type { BaseNode } from './base.ts'
 import type { SchemaNode } from './schema.ts'
 
@@ -41,18 +42,17 @@ export type ParameterNode = BaseNode & {
 type UserParameterNode = Pick<ParameterNode, 'name' | 'in' | 'schema'> & Partial<Omit<ParameterNode, 'kind' | 'name' | 'in' | 'schema'>>
 
 /**
- * Definition for the {@link ParameterNode}. `required` defaults to `false` and the
- * schema's `optional`/`nullish` flags are kept in sync with it.
+ * Definition for the {@link ParameterNode}. `required` defaults to `false`, and the schema's
+ * `optional`/`nullish` flags are derived from it through {@link optionality}.
  */
 export const parameterDef = defineNode<ParameterNode, UserParameterNode>({
   kind: 'Parameter',
   build: (props) => {
     const required = props.required ?? false
-    return { ...props, required, schema: syncOptionality(props.schema, required) }
+    return { ...props, required, schema: optionality(props.schema, required) }
   },
   children: ['schema'],
   visitorKey: 'parameter',
-  rebuild: true,
 })
 
 /**

package/src/nodes/property.ts

@@ -1,4 +1,5 @@
-import { defineNode, syncOptionality } from '../node.ts'
+import { defineNode } from '../defineNode.ts'
+import { optionality } from '../optionality.ts'
 import type { BaseNode } from './base.ts'
 import type { SchemaNode } from './schema.ts'
 
@@ -37,18 +38,17 @@ export type PropertyNode = BaseNode & {
 export type UserPropertyNode = Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>
 
 /**
- * Definition for the {@link PropertyNode}. `required` defaults to `false` and the
- * schema's `optional`/`nullish` flags are kept in sync with it.
+ * Definition for the {@link PropertyNode}. `required` defaults to `false`, and the schema's
+ * `optional`/`nullish` flags are derived from it through {@link optionality}.
  */
 export const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
   kind: 'Property',
   build: (props) => {
     const required = props.required ?? false
-    return { ...props, required, schema: syncOptionality(props.schema, required) }
+    return { ...props, required, schema: optionality(props.schema, required) }
   },
   children: ['schema'],
   visitorKey: 'property',
-  rebuild: true,
 })
 
 /**

package/src/nodes/requestBody.ts

@@ -1,6 +1,6 @@
-import { defineNode } from '../node.ts'
+import { defineNode } from '../defineNode.ts'
 import type { BaseNode } from './base.ts'
-import { type ContentNode, createContent, type UserContent } from './content.ts'
+import type { ContentNode } from './content.ts'
 
 /**
  * AST node representing an operation request body.
@@ -40,22 +40,15 @@ export type RequestBodyNode = BaseNode & {
 }
 
 /**
- * Loosely-typed request body accepted by `createOperation`, normalized into a {@link RequestBodyNode}.
+ * Definition for the {@link RequestBodyNode}. Content entries are built upfront with
+ * {@link createContent}, mirroring how `parameters` and `responses` take prebuilt nodes.
  */
-export type UserRequestBody = Omit<RequestBodyNode, 'kind' | 'content'> & {
-  content?: Array<UserContent>
-}
-
-/**
- * Definition for the {@link RequestBodyNode}, normalizing each content entry into a `ContentNode`.
- */
-export const requestBodyDef = defineNode<RequestBodyNode, UserRequestBody>({
+export const requestBodyDef = defineNode<RequestBodyNode>({
   kind: 'RequestBody',
-  build: (props) => ({ ...props, content: props.content?.map(createContent) }),
   children: ['content'],
 })
 
 /**
- * Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
+ * Creates a `RequestBodyNode`.
  */
 export const createRequestBody = requestBodyDef.create

package/src/nodes/response.ts

@@ -1,9 +1,94 @@
-import { defineNode } from '../node.ts'
+import { defineNode } from '../defineNode.ts'
 import type { BaseNode } from './base.ts'
-import { type ContentNode, createContent, type UserContent } from './content.ts'
-import type { StatusCode } from './http.ts'
+import { type ContentNode, createContent } from './content.ts'
 import type { SchemaNode } from './schema.ts'
 
+/**
+ * All supported HTTP status code literals as strings, as used in API specs
+ * (for example, `"200"` and `"404"`).
+ */
+type HttpStatusCode =
+  // 1xx Informational
+  | '100'
+  | '101'
+  | '102'
+  | '103'
+  // 2xx Success
+  | '200'
+  | '201'
+  | '202'
+  | '203'
+  | '204'
+  | '205'
+  | '206'
+  | '207'
+  | '208'
+  | '226'
+  // 3xx Redirection
+  | '300'
+  | '301'
+  | '302'
+  | '303'
+  | '304'
+  | '305'
+  | '307'
+  | '308'
+  // 4xx Client Error
+  | '400'
+  | '401'
+  | '402'
+  | '403'
+  | '404'
+  | '405'
+  | '406'
+  | '407'
+  | '408'
+  | '409'
+  | '410'
+  | '411'
+  | '412'
+  | '413'
+  | '414'
+  | '415'
+  | '416'
+  | '417'
+  | '418'
+  | '421'
+  | '422'
+  | '423'
+  | '424'
+  | '425'
+  | '426'
+  | '428'
+  | '429'
+  | '431'
+  | '451'
+  // 5xx Server Error
+  | '500'
+  | '501'
+  | '502'
+  | '503'
+  | '504'
+  | '505'
+  | '506'
+  | '507'
+  | '508'
+  | '510'
+  | '511'
+
+/**
+ * Response status code literal used by operations.
+ *
+ * Includes specific HTTP status code strings and `"default"` for catch-all responses.
+ *
+ * @example
+ * ```ts
+ * const status: StatusCode = '200'
+ * const fallback: StatusCode = 'default'
+ * ```
+ */
+export type StatusCode = HttpStatusCode | 'default'
+
 /**
  * AST node representing one operation response variant.
  *
@@ -16,7 +101,7 @@ import type { SchemaNode } from './schema.ts'
  * const response: ResponseNode = {
  *   kind: 'Response',
  *   statusCode: '200',
- *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
  * }
  * ```
  */
@@ -53,7 +138,7 @@ export type ResponseNode = BaseNode & {
 
 type ResponseInput = Pick<ResponseNode, 'statusCode'> &
   Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'content'>> & {
-    content?: Array<UserContent>
+    content?: Array<ContentNode>
     schema?: SchemaNode
     mediaType?: string | null
     keysToOmit?: Array<string> | null
@@ -67,8 +152,8 @@ export const responseDef = defineNode<ResponseNode, ResponseInput>({
   kind: 'Response',
   build: (props) => {
     const { schema, mediaType, keysToOmit, content, ...rest } = props
-    const entries = content ?? (schema ? [{ contentType: mediaType ?? 'application/json', schema, keysToOmit: keysToOmit ?? null }] : undefined)
-    return { ...rest, content: entries?.map(createContent) }
+    const entries = content ?? (schema ? [createContent({ contentType: mediaType ?? 'application/json', schema, keysToOmit: keysToOmit ?? null })] : undefined)
+    return { ...rest, content: entries }
   },
   children: ['content'],
   visitorKey: 'response',
@@ -81,7 +166,7 @@ export const responseDef = defineNode<ResponseNode, ResponseInput>({
  * ```ts
  * const response = createResponse({
  *   statusCode: '200',
- *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
+ *   content: [createContent({ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) })],
  * })
  * ```
  */