@kubb/ast 5.0.0-alpha.30 → 5.0.0-alpha.32

package/src/nodes/root.ts

@@ -8,10 +8,10 @@ import type { SchemaNode } from './schema.ts'
  *
  * @example
  * ```ts
- * const meta: RootMeta = { title: 'Pet API', version: '1.0.0' }
+ * const meta: InputMeta = { title: 'Pet API', version: '1.0.0' }
  * ```
  */
-export type RootMeta = {
+export type InputMeta = {
   /**
    * API title (from `info.title` in OAS/AsyncAPI).
    */
@@ -32,22 +32,23 @@ export type RootMeta = {
 }
 
 /**
- * Root AST node that contains all schemas and operations for one API document.
+ * Input AST node that contains all schemas and operations for one API document.
+ * Produced by the adapter and consumed by all Kubb plugins.
  *
  * @example
  * ```ts
- * const root: RootNode = {
- *   kind: 'Root',
+ * const input: InputNode = {
+ *   kind: 'Input',
  *   schemas: [],
  *   operations: [],
  * }
  * ```
  */
-export type RootNode = BaseNode & {
+export type InputNode = BaseNode & {
   /**
    * Node kind.
    */
-  kind: 'Root'
+  kind: 'Input'
   /**
    * All schema nodes in the document.
    */
@@ -59,5 +60,5 @@ export type RootNode = BaseNode & {
   /**
    * Optional document metadata populated by the adapter.
    */
-  meta?: RootMeta
+  meta?: InputMeta
 }

package/src/refs.ts

@@ -1,4 +1,4 @@
-import type { RootNode } from './nodes/root.ts'
+import type { InputNode } from './nodes/root.ts'
 import type { SchemaNode } from './nodes/schema.ts'
 
 /**
@@ -21,20 +21,20 @@ export function extractRefName(ref: string): string {
 }
 
 /**
- * Builds a `RefMap` from `root.schemas` using each schema's `name`.
+ * Builds a `RefMap` from `input.schemas` using each schema's `name`.
  *
  * Unnamed schemas are skipped.
  *
  * @example
  * ```ts
- * const refMap = buildRefMap(root)
+ * const refMap = buildRefMap(input)
  * const pet = refMap.get('Pet')
  * ```
  */
-export function buildRefMap(root: RootNode): RefMap {
+export function buildRefMap(input: InputNode): RefMap {
   const map: RefMap = new Map()
 
-  for (const schema of root.schemas) {
+  for (const schema of input.schemas) {
     if (schema.name) {
       map.set(schema.name, schema)
     }

package/src/types.ts

@@ -3,46 +3,58 @@ export type { DistributiveOmit } from './factory.ts'
 export type { InferSchema, InferSchemaNode, ParserOptions } from './infer.ts'
 export type {
   ArraySchemaNode,
+  ArrowFunctionNode,
   BaseNode,
+  CodeNode,
   ComplexSchemaType,
+  ConstNode,
   DateSchemaNode,
   DatetimeSchemaNode,
   EnumSchemaNode,
   EnumValueNode,
+  ExportNode,
+  FileNode,
   FormatStringSchemaNode,
   FunctionNode,
   FunctionNodeType,
   FunctionParameterNode,
   FunctionParametersNode,
+  FunctionParamNode,
   HttpMethod,
   HttpStatusCode,
+  ImportNode,
+  InputMeta,
+  InputNode,
   IntersectionSchemaNode,
   Ipv4SchemaNode,
   Ipv6SchemaNode,
+  JSDocNode,
   MediaType,
   Node,
   NodeKind,
   NumberSchemaNode,
   ObjectSchemaNode,
   OperationNode,
+  OutputNode,
   ParameterGroupNode,
   ParameterLocation,
   ParameterNode,
+  ParamsTypeNode,
   PrimitiveSchemaType,
   PropertyNode,
   RefSchemaNode,
   ResponseNode,
-  RootMeta,
-  RootNode,
   ScalarSchemaNode,
   ScalarSchemaType,
   SchemaNode,
   SchemaNodeByType,
   SchemaType,
+  SourceNode,
   SpecialSchemaType,
   StatusCode,
   StringSchemaNode,
   TimeSchemaNode,
+  TypeDeclarationNode,
   TypeNode,
   UnionSchemaNode,
   UrlSchemaNode,

package/src/utils.ts

@@ -1,8 +1,19 @@
 import { camelCase, isValidVarName } from '@internals/utils'
 
-import { createFunctionParameter, createFunctionParameters, createParameterGroup, createProperty, createSchema, createTypeNode } from './factory.ts'
+import { createFunctionParameter, createFunctionParameters, createParameterGroup, createParamsType, createProperty, createSchema } from './factory.ts'
 import { narrowSchema } from './guards.ts'
-import type { FunctionParameterNode, FunctionParametersNode, OperationNode, ParameterGroupNode, ParameterNode, SchemaNode, TypeNode } from './nodes/index.ts'
+import type {
+  ExportNode,
+  FunctionParameterNode,
+  FunctionParametersNode,
+  ImportNode,
+  OperationNode,
+  ParameterGroupNode,
+  ParameterNode,
+  ParamsTypeNode,
+  SchemaNode,
+  SourceNode,
+} from './nodes/index.ts'
 import type { SchemaType } from './nodes/schema.ts'
 
 const plainStringTypes = new Set<SchemaType>(['string', 'uuid', 'email', 'url', 'datetime'] as const)
@@ -118,7 +129,7 @@ export type ParamGroupType = {
   /**
    * TypeNode for the group type.
    */
-  type: TypeNode
+  type: ParamsTypeNode
   /**
    * Whether the parameter group is optional.
    */
@@ -251,9 +262,17 @@ export type CreateOperationParamsOptions = {
   typeWrapper?: (type: string) => string
 }
 
-function resolveType({ node, param, resolver }: { node: OperationNode; param: ParameterNode; resolver: OperationParamsResolver | undefined }): TypeNode {
+function resolveParamsType({
+  node,
+  param,
+  resolver,
+}: {
+  node: OperationNode
+  param: ParameterNode
+  resolver: OperationParamsResolver | undefined
+}): ParamsTypeNode {
   if (!resolver) {
-    return createTypeNode({ variant: 'reference', name: param.schema.primitive ?? 'unknown' })
+    return createParamsType({ variant: 'reference', name: param.schema.primitive ?? 'unknown' })
   }
 
   const individualName = resolver.resolveParamName(node, param)
@@ -269,10 +288,10 @@ function resolveType({ node, param, resolver }: { node: OperationNode; param: Pa
   const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : undefined
 
   if (groupName && groupName !== individualName) {
-    return createTypeNode({ variant: 'member', base: groupName, key: param.name })
+    return createParamsType({ variant: 'member', base: groupName, key: param.name })
   }
 
-  return createTypeNode({ variant: 'reference', name: individualName })
+  return createParamsType({ variant: 'reference', name: individualName })
 }
 
 /**
@@ -287,7 +306,7 @@ function resolveType({ node, param, resolver }: { node: OperationNode; param: Pa
  *   paramsType: 'inline',
  *   pathParamsType: 'inline',
  *   resolver: tsResolver,
- *   extraParams: [createFunctionParameter({ name: 'options', type: createTypeNode({ variant: 'reference', name: 'Partial<RequestOptions>' }), default: '{}' })],
+ *   extraParams: [createFunctionParameter({ name: 'options', type: createParamsType({ variant: 'reference', name: 'Partial<RequestOptions>' }), default: '{}' })],
  * })
  * ```
  */
@@ -299,10 +318,10 @@ export function createOperationParams(node: OperationNode, options: CreateOperat
   const headersName = paramNames?.headers ?? 'headers'
   const pathName = paramNames?.path ?? 'pathParams'
 
-  const wrapType = (type: string): TypeNode => createTypeNode({ variant: 'reference', name: typeWrapper ? typeWrapper(type) : type })
-  // Only reference TypeNodes are wrapped (they hold a plain type name string).
+  const wrapType = (type: string): ParamsTypeNode => createParamsType({ variant: 'reference', name: typeWrapper ? typeWrapper(type) : type })
+  // Only reference-variant TypeNodes are wrapped — they hold a plain type name string that needs casing applied.
   // Member and struct TypeNodes are pre-resolved structured expressions and are passed through unchanged.
-  const wrapTypeNode = (type: TypeNode): TypeNode => (type.variant === 'reference' ? wrapType(type.name) : type)
+  const wrapTypeNode = (type: ParamsTypeNode): ParamsTypeNode => (type.kind === 'ParamsType' && type.variant === 'reference' ? wrapType(type.name) : type)
 
   const casedParams = caseParams(node.parameters, paramsCasing)
   const pathParams = casedParams.filter((p) => p.in === 'path')
@@ -320,7 +339,7 @@ export function createOperationParams(node: OperationNode, options: CreateOperat
   if (paramsType === 'object') {
     const children: Array<FunctionParameterNode> = [
       ...pathParams.map((p) => {
-        const type = resolveType({ node, param: p, resolver })
+        const type = resolveParamsType({ node, param: p, resolver })
         return createFunctionParameter({ name: p.name, type: wrapTypeNode(type), optional: !p.required })
       }),
       ...(bodyType ? [createFunctionParameter({ name: dataName, type: bodyType, optional: !bodyRequired })] : []),
@@ -338,7 +357,7 @@ export function createOperationParams(node: OperationNode, options: CreateOperat
         params.push(createFunctionParameter({ name: pathName, type: spreadType ? wrapType(spreadType) : undefined, rest: true }))
       } else {
         const pathChildren = pathParams.map((p) => {
-          const type = resolveType({ node, param: p, resolver })
+          const type = resolveParamsType({ node, param: p, resolver })
           return createFunctionParameter({ name: p.name, type: wrapTypeNode(type), optional: !p.required })
         })
         params.push(
@@ -384,10 +403,10 @@ function buildGroupParam({
   params: Array<ParameterNode>
   groupType: ParamGroupType | undefined
   resolver: OperationParamsResolver | undefined
-  wrapType: (type: string) => TypeNode
+  wrapType: (type: string) => ParamsTypeNode
 }): Array<FunctionParameterNode> {
   if (groupType) {
-    const type = groupType.type.variant === 'reference' ? wrapType(groupType.type.name) : groupType.type
+    const type = groupType.type.kind === 'ParamsType' && groupType.type.variant === 'reference' ? wrapType(groupType.type.name) : groupType.type
     return [createFunctionParameter({ name, type, optional: groupType.optional })]
   }
   if (params.length) {
@@ -426,7 +445,7 @@ function resolveGroupType({
     return undefined
   }
   const allOptional = params.every((p) => !p.required)
-  return { type: createTypeNode({ variant: 'reference', name: groupName }), optional: allOptional }
+  return { type: createParamsType({ variant: 'reference', name: groupName }), optional: allOptional }
 }
 
 /**
@@ -443,9 +462,148 @@ function toStructType({
   node: OperationNode
   params: Array<ParameterNode>
   resolver: OperationParamsResolver | undefined
-}): TypeNode {
-  return createTypeNode({
+}): ParamsTypeNode {
+  return createParamsType({
     variant: 'struct',
-    properties: params.map((p) => ({ name: p.name, optional: !p.required, type: resolveType({ node, param: p, resolver }) })),
+    properties: params.map((p) => ({ name: p.name, optional: !p.required, type: resolveParamsType({ node, param: p, resolver }) })),
   })
 }
+
+function sourceKey(source: SourceNode): string {
+  return `${source.name ?? source.value ?? ''}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`
+}
+
+function pathTypeKey(path: string, isTypeOnly: boolean | undefined): string {
+  return `${path}:${isTypeOnly ?? false}`
+}
+
+function exportKey(path: string, name: string | undefined, isTypeOnly: boolean | undefined, asAlias: boolean | undefined): string {
+  return `${path}:${name ?? ''}:${isTypeOnly ?? false}:${asAlias ?? ''}`
+}
+
+function importKey(path: string, name: string | undefined, isTypeOnly: boolean | undefined): string {
+  return `${path}:${name ?? ''}:${isTypeOnly ?? false}`
+}
+
+/**
+ * Computes a multi-level sort key for exports and imports:
+ * non-array names first (wildcards/namespace aliases); type-only before value; alphabetical path; unnamed before named.
+ */
+function sortKey(node: { name?: string | Array<unknown>; isTypeOnly?: boolean; path: string }): string {
+  const isArray = Array.isArray(node.name) ? '1' : '0'
+  const typeOnly = node.isTypeOnly ? '0' : '1'
+  const hasName = node.name != null ? '1' : '0'
+  const name = Array.isArray(node.name) ? [...node.name].sort().join('\0') : (node.name ?? '')
+  return `${isArray}:${typeOnly}:${node.path}:${hasName}:${name}`
+}
+
+/**
+ * Deduplicates an array of `SourceNode` objects.
+ * Named sources are deduplicated by `name + isExportable + isTypeOnly`.
+ * Unnamed sources are deduplicated by `value`.
+ */
+export function combineSources(sources: Array<SourceNode>): Array<SourceNode> {
+  const seen = new Map<string, SourceNode>()
+  for (const source of sources) {
+    const key = sourceKey(source)
+    if (!seen.has(key)) seen.set(key, source)
+  }
+  return [...seen.values()]
+}
+
+/**
+ * Deduplicates and merges an array of `ExportNode` objects.
+ * Exports with the same path and `isTypeOnly` flag have their names merged.
+ */
+export function combineExports(exports: Array<ExportNode>): Array<ExportNode> {
+  const result: Array<ExportNode> = []
+  // Accumulates array-named exports keyed by `path:isTypeOnly` for name-merging
+  const namedByPath = new Map<string, ExportNode>()
+  // Deduplicates non-array exports by their exact identity
+  const seen = new Set<string>()
+
+  for (const curr of [...exports].sort((a, b) => {
+    const ka = sortKey(a)
+    const kb = sortKey(b)
+    return ka < kb ? -1 : ka > kb ? 1 : 0
+  })) {
+    const { name, path, isTypeOnly, asAlias } = curr
+
+    if (Array.isArray(name)) {
+      if (!name.length) continue
+
+      const key = pathTypeKey(path, isTypeOnly)
+      const existing = namedByPath.get(key)
+
+      if (existing && Array.isArray(existing.name)) {
+        existing.name = [...new Set([...existing.name, ...name])]
+      } else {
+        const newItem: ExportNode = { ...curr, name: [...new Set(name)] }
+        result.push(newItem)
+        namedByPath.set(key, newItem)
+      }
+    } else {
+      const key = exportKey(path, name, isTypeOnly, asAlias)
+      if (!seen.has(key)) {
+        result.push(curr)
+        seen.add(key)
+      }
+    }
+  }
+
+  return result
+}
+
+/**
+ * Deduplicates and merges an array of `ImportNode` objects.
+ * Filters out unused imports (names not referenced in `source` or re-exported).
+ * Imports with the same path and `isTypeOnly` flag have their names merged.
+ */
+export function combineImports(imports: Array<ImportNode>, exports: Array<ExportNode>, source?: string): Array<ImportNode> {
+  // Build a lookup of all exported names to retain imports that are re-exported
+  const exportedNames = new Set(exports.flatMap((e) => (Array.isArray(e.name) ? e.name : e.name ? [e.name] : [])))
+  const isUsed = (importName: string): boolean => !source || source.includes(importName) || exportedNames.has(importName)
+
+  const result: Array<ImportNode> = []
+  // Accumulates array-named imports keyed by `path:isTypeOnly` for name-merging
+  const namedByPath = new Map<string, ImportNode>()
+  // Deduplicates non-array imports by their exact identity
+  const seen = new Set<string>()
+
+  for (const curr of [...imports].sort((a, b) => {
+    const ka = sortKey(a)
+    const kb = sortKey(b)
+    return ka < kb ? -1 : ka > kb ? 1 : 0
+  })) {
+    if (curr.path === curr.root) continue
+
+    const { path, isTypeOnly } = curr
+    let { name } = curr
+
+    if (Array.isArray(name)) {
+      name = [...new Set(name)].filter((item) => (typeof item === 'string' ? isUsed(item) : isUsed(item.propertyName)))
+      if (!name.length) continue
+
+      const key = pathTypeKey(path, isTypeOnly)
+      const existing = namedByPath.get(key)
+
+      if (existing && Array.isArray(existing.name)) {
+        existing.name = [...new Set([...existing.name, ...name])]
+      } else {
+        const newItem: ImportNode = { ...curr, name }
+        result.push(newItem)
+        namedByPath.set(key, newItem)
+      }
+    } else {
+      if (name && !isUsed(name)) continue
+
+      const key = importKey(path, name, isTypeOnly)
+      if (!seen.has(key)) {
+        result.push(curr)
+        seen.add(key)
+      }
+    }
+  }
+
+  return result
+}

package/src/visitor.ts

@@ -1,7 +1,7 @@
 import type { VisitorDepth } from './constants.ts'
 import { visitorDepths, WALK_CONCURRENCY } from './constants.ts'
 import { createParameter, createProperty } from './factory.ts'
-import type { Node, OperationNode, ParameterNode, PropertyNode, ResponseNode, RootNode, SchemaNode } from './nodes/index.ts'
+import type { InputNode, Node, OperationNode, OutputNode, ParameterNode, PropertyNode, ResponseNode, SchemaNode } from './nodes/index.ts'
 
 /**
  * Creates a small async concurrency limiter.
@@ -51,9 +51,10 @@ type LimitFn = ReturnType<typeof createLimit>
  * `ParentOf` uses this map to find parent types.
  */
 type ParentNodeMap = [
-  [RootNode, undefined],
-  [OperationNode, RootNode],
-  [SchemaNode, RootNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode],
+  [InputNode, undefined],
+  [OutputNode, undefined],
+  [OperationNode, InputNode],
+  [SchemaNode, InputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode],
   [PropertyNode, SchemaNode],
   [ParameterNode, OperationNode],
   [ResponseNode, OperationNode],
@@ -67,7 +68,7 @@ type ParentNodeMap = [
  *
  * @example
  * ```ts
- * type RootParent = ParentOf<RootNode>
+ * type InputParent = ParentOf<InputNode>
  * // undefined
  * ```
  *
@@ -80,7 +81,7 @@ type ParentNodeMap = [
  * @example
  * ```ts
  * type SchemaParent = ParentOf<SchemaNode>
- * // RootNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode
+ * // InputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode
  * ```
  */
 export type ParentOf<T extends Node, TEntries extends ReadonlyArray<[Node, unknown]> = ParentNodeMap> = TEntries extends [
@@ -108,7 +109,7 @@ export type ParentOf<T extends Node, TEntries extends ReadonlyArray<[Node, unkno
 export type VisitorContext<T extends Node = Node> = {
   /**
    * Parent node of the currently visited node.
-   * For `RootNode`, this is `undefined`.
+   * For `InputNode`, this is `undefined`.
    */
   parent?: ParentOf<T>
 }
@@ -126,7 +127,8 @@ export type VisitorContext<T extends Node = Node> = {
  * ```
  */
 export type Visitor = {
-  root?(node: RootNode, context: VisitorContext<RootNode>): void | RootNode
+  input?(node: InputNode, context: VisitorContext<InputNode>): void | InputNode
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): void | OutputNode
   operation?(node: OperationNode, context: VisitorContext<OperationNode>): void | OperationNode
   schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): void | SchemaNode
   property?(node: PropertyNode, context: VisitorContext<PropertyNode>): void | PropertyNode
@@ -152,7 +154,8 @@ type MaybePromise<T> = T | Promise<T>
  * ```
  */
 export type AsyncVisitor = {
-  root?(node: RootNode, context: VisitorContext<RootNode>): MaybePromise<void | RootNode>
+  input?(node: InputNode, context: VisitorContext<InputNode>): MaybePromise<void | InputNode>
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): MaybePromise<void | OutputNode>
   operation?(node: OperationNode, context: VisitorContext<OperationNode>): MaybePromise<void | OperationNode>
   schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): MaybePromise<void | SchemaNode>
   property?(node: PropertyNode, context: VisitorContext<PropertyNode>): MaybePromise<void | PropertyNode>
@@ -173,7 +176,8 @@ export type AsyncVisitor = {
  * ```
  */
 export type CollectVisitor<T> = {
-  root?(node: RootNode, context: VisitorContext<RootNode>): T | undefined
+  input?(node: InputNode, context: VisitorContext<InputNode>): T | undefined
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): T | undefined
   operation?(node: OperationNode, context: VisitorContext<OperationNode>): T | undefined
   schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): T | undefined
   property?(node: PropertyNode, context: VisitorContext<PropertyNode>): T | undefined
@@ -263,8 +267,10 @@ export type CollectOptions<T> = CollectVisitor<T> & {
  */
 function getChildren(node: Node, recurse: boolean): Array<Node> {
   switch (node.kind) {
-    case 'Root':
+    case 'Input':
       return [...node.schemas, ...node.operations]
+    case 'Output':
+      return []
     case 'Operation':
       return [...node.parameters, ...(node.requestBody?.schema ? [node.requestBody.schema] : []), ...node.responses]
     case 'Schema': {
@@ -290,6 +296,8 @@ function getChildren(node: Node, recurse: boolean): Array<Node> {
     case 'FunctionParameters':
     case 'Type':
       return []
+    default:
+      return []
   }
 }
 
@@ -322,8 +330,11 @@ export async function walk(node: Node, options: WalkOptions): Promise<void> {
 
 async function _walk(node: Node, visitor: AsyncVisitor, recurse: boolean, limit: LimitFn, parent: Node | undefined): Promise<void> {
   switch (node.kind) {
-    case 'Root':
-      await limit(() => visitor.root?.(node, { parent: parent as ParentOf<RootNode> }))
+    case 'Input':
+      await limit(() => visitor.input?.(node, { parent: parent as ParentOf<InputNode> }))
+      break
+    case 'Output':
+      await limit(() => visitor.output?.(node, { parent: parent as ParentOf<OutputNode> }))
       break
     case 'Operation':
       await limit(() => visitor.operation?.(node, { parent: parent as ParentOf<OperationNode> }))
@@ -373,7 +384,8 @@ async function _walk(node: Node, visitor: AsyncVisitor, recurse: boolean, limit:
  * const next = transform(root, { depth: 'shallow', root: (node) => node })
  * ```
  */
-export function transform(node: RootNode, options: TransformOptions): RootNode
+export function transform(node: InputNode, options: TransformOptions): InputNode
+export function transform(node: OutputNode, options: TransformOptions): OutputNode
 export function transform(node: OperationNode, options: TransformOptions): OperationNode
 export function transform(node: SchemaNode, options: TransformOptions): SchemaNode
 export function transform(node: PropertyNode, options: TransformOptions): PropertyNode
@@ -385,17 +397,24 @@ export function transform(node: Node, options: TransformOptions): Node {
   const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep
 
   switch (node.kind) {
-    case 'Root': {
-      let root = node
-      const replaced = visitor.root?.(root, { parent: parent as ParentOf<RootNode> })
-      if (replaced) root = replaced
+    case 'Input': {
+      let input = node
+      const replaced = visitor.input?.(input, { parent: parent as ParentOf<InputNode> })
+      if (replaced) input = replaced
 
       return {
-        ...root,
-        schemas: root.schemas.map((s) => transform(s, { ...options, parent: root })),
-        operations: root.operations.map((op) => transform(op, { ...options, parent: root })),
+        ...input,
+        schemas: input.schemas.map((s) => transform(s, { ...options, parent: input })),
+        operations: input.operations.map((op) => transform(op, { ...options, parent: input })),
       }
     }
+    case 'Output': {
+      let output = node
+      const replaced = visitor.output?.(output, { parent: parent as ParentOf<OutputNode> })
+      if (replaced) output = replaced
+
+      return output
+    }
     case 'Operation': {
       let op = node
       const replaced = visitor.operation?.(op, { parent: parent as ParentOf<OperationNode> })
@@ -462,6 +481,8 @@ export function transform(node: Node, options: TransformOptions): Node {
     case 'FunctionParameters':
     case 'Type':
       return node
+    default:
+      return node
   }
 }
 
@@ -481,8 +502,11 @@ export function transform(node: Node, options: TransformOptions): Node {
  */
 export function composeTransformers(...visitors: Array<Visitor>): Visitor {
   return {
-    root(node, context) {
-      return visitors.reduce<RootNode>((acc, v) => v.root?.(acc, context) ?? acc, node)
+    input(node, context) {
+      return visitors.reduce<InputNode>((acc, v) => v.input?.(acc, context) ?? acc, node)
+    },
+    output(node, context) {
+      return visitors.reduce<OutputNode>((acc, v) => v.output?.(acc, context) ?? acc, node)
     },
     operation(node, context) {
       return visitors.reduce<OperationNode>((acc, v) => v.operation?.(acc, context) ?? acc, node)
@@ -529,8 +553,11 @@ export function collect<T>(node: Node, options: CollectOptions<T>): Array<T> {
 
   let v: T | undefined
   switch (node.kind) {
-    case 'Root':
-      v = visitor.root?.(node, { parent: parent as ParentOf<RootNode> })
+    case 'Input':
+      v = visitor.input?.(node, { parent: parent as ParentOf<InputNode> })
+      break
+    case 'Output':
+      v = visitor.output?.(node, { parent: parent as ParentOf<OutputNode> })
       break
     case 'Operation':
       v = visitor.operation?.(node, { parent: parent as ParentOf<OperationNode> })