@kubb/adapter-oas 5.0.0-beta.57 → 5.0.0-beta.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/adapter-oas",
-  "version": "5.0.0-beta.57",
+  "version": "5.0.0-beta.59",
   "description": "OpenAPI and Swagger adapter for Kubb. Parses and validates OAS 2.0/3.x specifications into a @kubb/ast RootNode for downstream code generation plugins.",
   "keywords": [
     "adapter",
@@ -46,8 +46,8 @@
     "api-ref-bundler": "0.5.1",
     "swagger2openapi": "^7.0.8",
     "yaml": "^2.9.0",
-    "@kubb/ast": "5.0.0-beta.57",
-    "@kubb/core": "5.0.0-beta.57"
+    "@kubb/ast": "5.0.0-beta.59",
+    "@kubb/core": "5.0.0-beta.59"
   },
   "devDependencies": {
     "@types/json-schema": "^7.0.15",

package/src/adapter.ts

@@ -191,7 +191,7 @@ export const adapterOas = createAdapter<AdapterOas>((options) => {
           const result = resolve(schemaName)
           if (!result) return null
 
-          return ast.createImport({ name: [result.name], path: result.path })
+          return ast.factory.createImport({ name: [result.name], path: result.path })
         },
       })
     },
@@ -200,7 +200,7 @@ export const adapterOas = createAdapter<AdapterOas>((options) => {
 
       const [schemas, operations] = await Promise.all([Array.fromAsync(streamNode.schemas), Array.fromAsync(streamNode.operations)])
 
-      return ast.createInput({ schemas, operations, meta: streamNode.meta })
+      return ast.factory.createInput({ schemas, operations, meta: streamNode.meta })
     },
     stream: createStream,
   }

package/src/constants.ts

@@ -73,7 +73,7 @@ export const structuralKeys = new Set(['properties', 'items', 'additionalPropert
  *
  * Only formats whose AST type differs from the OAS `type` field appear here.
  * Formats that depend on runtime options (`int64`, `date-time`, `date`, `time`) are handled separately
- * in the parser. `ipv4` and `ipv6` map to their own dedicated schema types; `hostname` and
+ * in the parser. `ipv4` and `ipv6` map to their own dedicated schema types. `hostname` and
  * `idn-hostname` map to `'url'` as the closest generic string-format type.
  *
  * @example
@@ -126,8 +126,8 @@ export const formatMap = {
 export const enumExtensionKeys = ['x-enumNames', 'x-enum-varnames'] as const
 
 /**
- * Maps `'any' | 'unknown' | 'void'` option strings to their `ScalarSchemaType` constant.
- * Replaces a plain object lookup with a `Map` for explicit key membership testing via `.has()`.
+ * Maps the `unknownType`/`emptySchemaType` option string to its `ScalarSchemaType` constant.
+ * A `Map` (over a plain object) lets callers test key membership with `.has()`.
  */
 export const typeOptionMap = new Map<'any' | 'unknown' | 'void', ast.ScalarSchemaType>([
   ['any', ast.schemaTypes.any],

package/src/discriminator.ts

@@ -82,11 +82,51 @@ export function patchDiscriminatorNode(node: ast.SchemaNode, entry: { propertyNa
   if (!objectNode) return node
 
   const { propertyName, enumValues } = entry
-  const enumSchema = ast.createSchema({ type: 'enum', enumValues })
-  const newProp = ast.createProperty({ name: propertyName, required: true, schema: enumSchema })
+  const enumSchema = ast.factory.createSchema({ type: 'enum', enumValues })
+  const newProp = ast.factory.createProperty({ name: propertyName, required: true, schema: enumSchema })
 
   const existingIdx = objectNode.properties.findIndex((p) => p.name === propertyName)
   const newProperties = existingIdx >= 0 ? objectNode.properties.map((p, i) => (i === existingIdx ? newProp : p)) : [...objectNode.properties, newProp]
 
   return { ...objectNode, properties: newProperties }
 }
+
+/**
+ * Creates a single-property object schema used as a discriminator literal.
+ *
+ * @example
+ * ```ts
+ * createDiscriminantNode({ propertyName: 'type', value: 'dog' })
+ * // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
+ * ```
+ */
+export function createDiscriminantNode({ propertyName, value }: { propertyName: string; value: string }): ast.SchemaNode {
+  return ast.factory.createSchema({
+    type: 'object',
+    primitive: 'object',
+    properties: [
+      ast.factory.createProperty({
+        name: propertyName,
+        schema: ast.factory.createSchema({
+          type: 'enum',
+          primitive: 'string',
+          enumValues: [value],
+        }),
+        required: true,
+      }),
+    ],
+  })
+}
+
+/**
+ * Returns the discriminator key whose mapping value matches `ref`, or `null` when there is no match.
+ *
+ * @example
+ * ```ts
+ * findDiscriminator({ dog: '#/components/schemas/Dog' }, '#/components/schemas/Dog') // 'dog'
+ * ```
+ */
+export function findDiscriminator(mapping: Record<string, string> | undefined, ref: string | undefined): string | null {
+  if (!mapping || !ref) return null
+  return Object.entries(mapping).find(([, value]) => value === ref)?.[0] ?? null
+}

package/src/parser.ts

@@ -1,8 +1,9 @@
 import { pascalCase } from '@internals/utils'
-import { childName, enumPropName, extractRefName, findDiscriminator } from '@kubb/ast/utils'
+import { childName, enumPropName, extractRefName } from '@kubb/ast/utils'
 import { ast } from '@kubb/core'
 import { DEFAULT_PARSER_OPTIONS, enumExtensionKeys, SCHEMA_REF_PREFIX, typeOptionMap } from './constants.ts'
 import { oasDialect, type OasDialect } from './dialect.ts'
+import { createDiscriminantNode, findDiscriminator } from './discriminator.ts'
 import { getOperationId, getOperations, getRequestContentType, getResponseByStatusCode, getResponseStatusCodes } from './operation.ts'
 import {
   buildSchemaNode,
@@ -66,11 +67,17 @@ type SchemaContext = {
  * that is not convertible falls through to plain `type` handling).
  */
 type SchemaRule = {
-  /** Identifies the rule when reading the table or debugging which branch ran. */
+  /**
+   * Identifies the rule when reading the table or debugging which branch ran.
+   */
   name: string
-  /** Returns `true` when this rule is responsible for the given context. */
+  /**
+   * Returns `true` when this rule is responsible for the given context.
+   */
   match: (context: SchemaContext) => boolean
-  /** Produces a node for the context, or `null` to fall through to the next rule. */
+  /**
+   * Produces a node for the context, or `null` to fall through to the next rule.
+   */
   convert: (context: SchemaContext) => ast.SchemaNode | null
 }
 
@@ -78,9 +85,9 @@ type SchemaRule = {
  * Normalizes malformed `{ type: 'array', enum: [...] }` schemas by moving enum values into items.
  *
  * This pattern violates the OpenAPI spec but appears in real specs. The fix moves enum values
- * from the array to its items sub-schema, making them valid for downstream processing.
+ * from the array to its items sub-schema, so they are valid for downstream processing.
  *
- * @note This is a defensive measure for robustness with non-compliant specs.
+ * @note A defensive measure for non-compliant specs.
  */
 function normalizeArrayEnum(schema: SchemaObject): SchemaObject {
   const isItemsObject = typeof schema.items === 'object' && !Array.isArray(schema.items)
@@ -98,7 +105,7 @@ function normalizeArrayEnum(schema: SchemaObject): SchemaObject {
  *
  * Returns closures that share mutable state (`resolvingRefs` set for cycle detection).
  * Each converter branch (`convertRef`, `convertAllOf`, etc.) mutually recursively calls `parseSchema`,
- * made possible by hoisting of function declarations.
+ * which works because function declarations hoist.
  *
  * @internal
  */
@@ -151,7 +158,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
       resolvedSchema = resolvedRefCache.get(refPath) ?? null
     }
 
-    return ast.createSchema({
+    return ast.factory.createSchema({
       ...buildSchemaNode(schema, name, nullable, defaultValue),
       type: 'ref',
       name: extractRefName(schema.$ref!),
@@ -176,7 +183,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
       const mergedNullable = nullable || memberNode.nullable || undefined
       const mergedDefault = schema.default === null && mergedNullable ? undefined : (schema.default ?? memberNode.default)
 
-      return ast.createSchema({
+      return ast.factory.createSchema({
         ...memberNodeProps,
         name,
         title: schema.title ?? memberNode.title,
@@ -264,10 +271,10 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
     }
 
     for (const { propertyName, value } of filteredDiscriminantValues) {
-      allOfMembers.push(ast.createDiscriminantNode({ propertyName, value }))
+      allOfMembers.push(createDiscriminantNode({ propertyName, value }))
     }
 
-    return ast.createSchema({
+    return ast.factory.createSchema({
       type: 'intersection',
       members: [...ast.mergeAdjacentObjectsLazy(allOfMembers.slice(0, syntheticStart)), ...ast.mergeAdjacentObjectsLazy(allOfMembers.slice(syntheticStart))],
       ...buildSchemaNode(schema, name, nullable, defaultValue),
@@ -286,7 +293,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
         return null
       }
 
-      return ast.createSchema({
+      return ast.factory.createSchema({
         type: 'object',
         primitive: 'object',
         properties: [discriminatorProperty],
@@ -332,12 +339,12 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
             )
           : undefined
 
-        return ast.createSchema({
+        return ast.factory.createSchema({
           type: 'intersection',
           members: [
             memberNode,
             narrowedDiscriminatorNode ??
-              ast.createDiscriminantNode({
+              createDiscriminantNode({
                 propertyName: discriminator.propertyName,
                 value: discriminatorValue,
               }),
@@ -345,7 +352,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
         })
       })
 
-      const unionNode = ast.createSchema({
+      const unionNode = ast.factory.createSchema({
         type: 'union',
         ...unionBase,
         members,
@@ -355,14 +362,14 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
         return unionNode
       }
 
-      return ast.createSchema({
+      return ast.factory.createSchema({
         type: 'intersection',
         ...buildSchemaNode(schema, name, nullable, defaultValue),
         members: [unionNode, sharedPropertiesNode],
       })
     }
 
-    return ast.createSchema({
+    return ast.factory.createSchema({
       type: 'union',
       ...unionBase,
       members: ast.simplifyUnion(unionMembers.map((s) => parseSchema({ schema: s as SchemaObject, name }, rawOptions))),
@@ -376,7 +383,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
     const constValue = schema.const
 
     if (constValue === null) {
-      return ast.createSchema({
+      return ast.factory.createSchema({
         type: 'null',
         primitive: 'null',
         name,
@@ -388,7 +395,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
     }
 
     const constPrimitive = getPrimitiveType(typeof constValue === 'number' ? 'number' : typeof constValue === 'boolean' ? 'boolean' : 'string')
-    return ast.createSchema({
+    return ast.factory.createSchema({
       type: 'enum',
       primitive: constPrimitive,
       enumValues: [constValue as string | number | boolean],
@@ -404,7 +411,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
     const base = buildSchemaNode(schema, name, nullable, defaultValue)
 
     if (schema.format === 'int64') {
-      return ast.createSchema({
+      return ast.factory.createSchema({
         type: options.integerType === 'bigint' ? 'bigint' : 'integer',
         primitive: 'integer',
         ...base,
@@ -420,7 +427,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
       if (!dateType) return null
 
       if (dateType.type === 'datetime') {
-        return ast.createSchema({
+        return ast.factory.createSchema({
           ...base,
           primitive: 'string' as const,
           type: 'datetime',
@@ -428,7 +435,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
           local: dateType.local,
         })
       }
-      return ast.createSchema({
+      return ast.factory.createSchema({
         ...base,
         primitive: 'string' as const,
         type: dateType.type,
@@ -442,14 +449,14 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
     const specialPrimitive: ast.PrimitiveSchemaType = specialType === 'number' || specialType === 'integer' || specialType === 'bigint' ? specialType : 'string'
 
     if (specialType === 'number' || specialType === 'integer' || specialType === 'bigint') {
-      return ast.createSchema({
+      return ast.factory.createSchema({
         ...base,
         primitive: specialPrimitive,
         type: specialType,
       })
     }
     if (specialType === 'url') {
-      return ast.createSchema({
+      return ast.factory.createSchema({
         ...base,
         primitive: 'string' as const,
         type: 'url',
@@ -458,21 +465,21 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
       })
     }
     if (specialType === 'ipv4') {
-      return ast.createSchema({
+      return ast.factory.createSchema({
         ...base,
         primitive: 'string' as const,
         type: 'ipv4',
       })
     }
     if (specialType === 'ipv6') {
-      return ast.createSchema({
+      return ast.factory.createSchema({
         ...base,
         primitive: 'string' as const,
         type: 'ipv6',
       })
     }
     if (specialType === 'uuid' || specialType === 'email') {
-      return ast.createSchema({
+      return ast.factory.createSchema({
         ...base,
         primitive: 'string' as const,
         type: specialType,
@@ -481,7 +488,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
       })
     }
 
-    return ast.createSchema({
+    return ast.factory.createSchema({
       ...base,
       primitive: specialPrimitive,
       type: specialType as ast.ScalarSchemaType,
@@ -503,7 +510,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
     // render as `never` (plugin-ts) / invalid `z.enum([])` (plugin-zod). Mirror the `const: null`
     // branch so it renders as a clean `null` (not `z.null().nullable()`).
     if (nullInEnum && filteredValues.length === 0) {
-      return ast.createSchema({
+      return ast.factory.createSchema({
         type: 'null',
         primitive: 'null',
         name,
@@ -543,7 +550,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
       const uniqueValues = [...new Set(filteredValues)]
       const seenNames = new Set<string>()
 
-      return ast.createSchema({
+      return ast.factory.createSchema({
         ...enumBase,
         primitive: enumPrimitiveType,
         namedEnumValues: uniqueValues
@@ -560,7 +567,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
       })
     }
 
-    return ast.createSchema({
+    return ast.factory.createSchema({
       ...enumBase,
       enumValues: [...new Set(filteredValues)],
     })
@@ -590,7 +597,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
             return node
           })()
 
-          return ast.createProperty({
+          return ast.factory.createProperty({
             name: propName,
             schema: {
               ...schemaNode,
@@ -608,7 +615,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
       if (additionalProperties && Object.keys(additionalProperties).length > 0) {
         return parseSchema({ schema: additionalProperties as SchemaObject }, rawOptions)
       }
-      if (additionalProperties) return ast.createSchema({ type: typeOptionMap.get(options.unknownType)! })
+      if (additionalProperties) return ast.factory.createSchema({ type: typeOptionMap.get(options.unknownType)! })
       return undefined
     })()
 
@@ -619,7 +626,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
           Object.entries(rawPatternProperties).map(([pattern, patternSchema]) => [
             pattern,
             patternSchema === true || (typeof patternSchema === 'object' && Object.keys(patternSchema).length === 0)
-              ? ast.createSchema({
+              ? ast.factory.createSchema({
                   type: typeOptionMap.get(options.unknownType)!,
                 })
               : parseSchema({ schema: patternSchema as SchemaObject }, rawOptions),
@@ -627,7 +634,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
         )
       : undefined
 
-    const objectNode: ast.SchemaNode = ast.createSchema({
+    const objectNode: ast.SchemaNode = ast.factory.createSchema({
       type: 'object',
       primitive: 'object',
       properties,
@@ -658,9 +665,9 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
    */
   function convertTuple({ schema, name, nullable, defaultValue, rawOptions }: SchemaContext): ast.SchemaNode {
     const tupleItems = (schema.prefixItems ?? []).map((item) => parseSchema({ schema: item as SchemaObject }, rawOptions))
-    const rest = schema.items ? parseSchema({ schema: schema.items as SchemaObject }, rawOptions) : ast.createSchema({ type: 'any' })
+    const rest = schema.items ? parseSchema({ schema: schema.items as SchemaObject }, rawOptions) : ast.factory.createSchema({ type: 'any' })
 
-    return ast.createSchema({
+    return ast.factory.createSchema({
       type: 'tuple',
       primitive: 'array',
       items: tupleItems,
@@ -679,7 +686,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
     const itemName = rawItems?.enum?.length && name ? enumPropName(null, name, options.enumSuffix) : name
     const items = rawItems ? [parseSchema({ schema: rawItems, name: itemName }, rawOptions)] : []
 
-    return ast.createSchema({
+    return ast.factory.createSchema({
       type: 'array',
       primitive: 'array',
       items,
@@ -694,7 +701,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
    * Converts a `type: 'string'` schema into a `StringSchemaNode`.
    */
   function convertString({ schema, name, nullable, defaultValue }: SchemaContext): ast.SchemaNode {
-    return ast.createSchema({
+    return ast.factory.createSchema({
       type: 'string',
       primitive: 'string',
       min: schema.minLength,
@@ -708,7 +715,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
    * Converts a `type: 'number'` or `type: 'integer'` schema.
    */
   function convertNumeric({ schema, name, nullable, defaultValue }: SchemaContext, type: 'number' | 'integer'): ast.SchemaNode {
-    return ast.createSchema({
+    return ast.factory.createSchema({
       type,
       primitive: type,
       min: schema.minimum,
@@ -724,7 +731,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
    * Converts a `type: 'boolean'` schema.
    */
   function convertBoolean({ schema, name, nullable, defaultValue }: SchemaContext): ast.SchemaNode {
-    return ast.createSchema({
+    return ast.factory.createSchema({
       type: 'boolean',
       primitive: 'boolean',
       ...buildSchemaNode(schema, name, nullable, defaultValue),
@@ -735,7 +742,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
    * Converts an explicit `type: 'null'` schema.
    */
   function convertNull({ schema, name, nullable }: SchemaContext): ast.SchemaNode {
-    return ast.createSchema({
+    return ast.factory.createSchema({
       type: 'null',
       primitive: 'null',
       name,
@@ -752,7 +759,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
    * into a `blob` node.
    */
   function convertBlob({ schema, name, nullable, defaultValue }: SchemaContext): ast.SchemaNode {
-    return ast.createSchema({
+    return ast.factory.createSchema({
       type: 'blob',
       primitive: 'string',
       ...buildSchemaNode(schema, name, nullable, defaultValue),
@@ -771,7 +778,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
     if (nonNullTypes.length <= 1) return null
 
     const arrayNullable = types.includes('null') || nullable || undefined
-    return ast.createSchema({
+    return ast.factory.createSchema({
       type: 'union',
       members: nonNullTypes.map((t) => parseSchema({ schema: { ...schema, type: t } as SchemaObject, name }, rawOptions)),
       ...buildSchemaNode(schema, name, arrayNullable, defaultValue),
@@ -859,7 +866,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
     }
 
     const emptyType = typeOptionMap.get(options.emptySchemaType)!
-    return ast.createSchema({
+    return ast.factory.createSchema({
       type: emptyType as ast.ScalarSchemaType,
       name,
       title: schema.title,
@@ -878,9 +885,9 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
 
     const schema: ast.SchemaNode = param['schema']
       ? parseSchema({ schema: param['schema'] as SchemaObject, name: schemaName }, options)
-      : ast.createSchema({ type: typeOptionMap.get(options.unknownType)! })
+      : ast.factory.createSchema({ type: typeOptionMap.get(options.unknownType)! })
 
-    return ast.createParameter({
+    return ast.factory.createParameter({
       name: paramName,
       in: param['in'] as ast.ParameterLocation,
       schema: {
@@ -996,7 +1003,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
         const node =
           raw && Object.keys(raw).length > 0
             ? parseSchema({ schema: raw, name: responseName }, options)
-            : ast.createSchema({ type: typeOptionMap.get(options.emptySchemaType)! })
+            : ast.factory.createSchema({ type: typeOptionMap.get(options.emptySchemaType)! })
         return { schema: node, keysToOmit: collectPropertyKeysByFlag(raw, 'writeOnly') }
       }
 
@@ -1011,7 +1018,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
         content.push({ contentType: getRequestContentType({ document, operation }) || 'application/json', ...parseEntrySchema(ctx.contentType) })
       }
 
-      return ast.createResponse({
+      return ast.factory.createResponse({
         statusCode: statusCode as ast.StatusCode,
         description,
         content,
@@ -1027,7 +1034,7 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
       return typeof fallback === 'string' ? fallback : undefined
     }
 
-    return ast.createOperation({
+    return ast.factory.createOperation({
       operationId,
       protocol: 'http',
       method: operation.method.toUpperCase() as ast.HttpMethod,
@@ -1048,10 +1055,11 @@ export function createSchemaParser(ctx: OasParserContext, dialect: OasDialect =
 /**
  * Parses a single OpenAPI `SchemaObject` into a `SchemaNode`.
  *
- * Use this for targeted schema parsing when you don't need the full spec.
- * For complete spec parsing, use `parseOas()` instead which handles operations and all schemas together.
+ * Reach for this when you only need one schema, not the whole spec. To parse a full spec
+ * with its operations and schemas, call `parseOas()`.
  *
- * @note Circular schema references are tracked via internal state and resolve appropriately.
+ * @note Internal state tracks `$ref` paths under resolution, so circular schemas stop
+ * recursing instead of looping.
  *
  * @example
  * ```ts
@@ -1072,7 +1080,8 @@ export function parseSchema(
  * Parses an OpenAPI specification into Kubb's universal `InputNode` AST.
  *
  * This is the main entry point for `@kubb/adapter-oas`. It converts OpenAPI/Swagger specs into a spec-agnostic tree
- * that downstream plugins (`plugin-ts`, `plugin-zod`, etc.) consume for code generation. No code is generated here,  * the tree is a pure data structure representing all schemas and operations.
+ * that downstream plugins (`plugin-ts`, `plugin-zod`, etc.) consume for code generation. No code is generated here.
+ * The tree is a pure data structure of all schemas and operations.
  *
  * Returns the AST root and a `nameMapping` for resolving schema references.
  *
@@ -1105,7 +1114,7 @@ export function parseOas(
     .map((operation) => _parseOperation(mergedOptions, operation))
     .filter((op): op is ast.OperationNode => op !== null)
 
-  const root = ast.createInput({ schemas, operations })
+  const root = ast.factory.createInput({ schemas, operations })
 
   return { root, nameMapping }
 }

package/src/resolvers.ts

@@ -470,7 +470,7 @@ export function getSchemas(document: Document, { contentType }: GetSchemasOption
 
 /**
  * Resolves the AST type descriptor for a date/time format, honoring the `dateType` option.
- * Returns `null` when `dateType: false`, signalling the format should fall through to `string`.
+ * Returns `null` when `dateType: false`, so the format falls through to `string`.
  */
 export function getDateType(
   options: ast.ParserOptions,

package/src/stream.ts

@@ -1,3 +1,4 @@
+import { containsCircularRef, findCircularSchemas } from '@kubb/ast/utils'
 import { ast } from '@kubb/core'
 import { SCHEMA_REF_PREFIX } from './constants.ts'
 import { buildDiscriminatorChildMap, patchDiscriminatorNode } from './discriminator.ts'
@@ -22,7 +23,7 @@ export type PreScanResult = {
  *
  * Only enums and objects are candidates, and object shapes that reference a circular schema are
  * rejected to avoid hoisting recursive structures. Inline shapes reuse their context-derived
- * name (collision-resolved against existing component names); shapes without a name stay inline.
+ * name (collision-resolved against existing component names). Shapes without a name stay inline.
  */
 function createDedupePlan({
   schemaNodes,
@@ -44,7 +45,7 @@ function createDedupePlan({
       if (node.type !== 'object') return false
       // Skip object shapes that are part of a circular chain, hoisting them would break the cycle.
       if (node.name && circularSchemas.has(node.name)) return false
-      return !ast.containsCircularRef(node, { circularSchemas })
+      return !containsCircularRef(node, { circularSchemas })
     },
     nameFor: (node) => {
       const base = node.name
@@ -149,7 +150,7 @@ export function preScan({
     }
   }
 
-  const circularNames = [...ast.findCircularSchemas(allNodes)]
+  const circularNames = [...findCircularSchemas(allNodes)]
   const discriminatorChildMap = discriminatorParentNodes.length > 0 ? buildDiscriminatorChildMap(discriminatorParentNodes) : null
 
   let dedupePlan: ast.DedupePlan | null = null
@@ -217,14 +218,14 @@ export function createInputStream({
   meta: ast.InputMeta
 }): ast.InputNode<true> {
   // Rewrites a top-level schema against the dedupe plan: a structurally identical sibling
-  // becomes a `ref` alias to the canonical one (keeping its own name); otherwise nested
+  // becomes a `ref` alias to the canonical one (keeping its own name). Otherwise nested
   // duplicates are collapsed while the schema's own root is preserved.
   const rewriteTopLevelSchema = (node: ast.SchemaNode): ast.SchemaNode => {
     if (!dedupePlan) return node
 
     const canonical = dedupePlan.canonicalBySignature.get(ast.signatureOf(node))
     if (canonical && canonical.name !== node.name) {
-      return ast.createSchema({
+      return ast.factory.createSchema({
         type: 'ref',
         name: node.name ?? null,
         ref: canonical.ref,
@@ -278,5 +279,5 @@ export function createInputStream({
     },
   }
 
-  return ast.createStreamInput(schemasIterable, operationsIterable, meta)
+  return ast.factory.createInput({ stream: true, schemas: schemasIterable, operations: operationsIterable, meta })
 }