@kubb/ast 5.0.0-beta.59 → 5.0.0-beta.60

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["extractRefName","obj","inputDef","outputDef","operationDef","requestBodyDef","contentDef","responseDef","schemaDef","propertyDef","parameterDef","functionParameterDef","functionParametersDef","typeLiteralDef","indexedAccessTypeDef","objectBindingPatternDef","constDef","typeDef","functionDef","arrowFunctionDef","textDef","breakDef","jsxDef","importDef","exportDef","sourceDef","fileDef","createSchema","extractRefName","narrowSchema","createSchema","createProperty","enumPropName"],"sources":["../src/constants.ts","../src/signature.ts","../src/registry.ts","../src/visitor.ts","../src/dedupe.ts","../src/dialect.ts","../src/printer.ts","../src/transformers.ts"],"sourcesContent":["import type { HttpMethod } from './nodes/operation.ts'\nimport type { SchemaType } from './nodes/schema.ts'\n\n/**\n * Traversal depth for AST visitor utilities.\n *\n * - `'shallow'` visits only the immediate node, skipping children.\n * - `'deep'` recursively visits all descendant nodes.\n */\nexport type VisitorDepth = 'shallow' | 'deep'\n\nexport const visitorDepths = {\n  shallow: 'shallow',\n  deep: 'deep',\n} as const satisfies Record<VisitorDepth, VisitorDepth>\n\n/**\n * Schema type discriminators used by all AST schema nodes.\n *\n * Each value is a stable discriminator across the AST (for example `schema.type === schemaTypes.object`).\n * Call `isScalarPrimitive()` to check for the scalar types.\n */\nexport const schemaTypes = {\n  /**\n   * Text value.\n   */\n  string: 'string',\n  /**\n   * Floating-point number (`float`, `double`).\n   */\n  number: 'number',\n  /**\n   * Whole number (`int32`). Use `bigint` for `int64`.\n   */\n  integer: 'integer',\n  /**\n   * 64-bit integer (`int64`). Only used when `integerType` is set to `'bigint'`.\n   */\n  bigint: 'bigint',\n  /**\n   * Boolean value.\n   */\n  boolean: 'boolean',\n  /**\n   * Explicit null value.\n   */\n  null: 'null',\n  /**\n   * Any value (no type restriction).\n   */\n  any: 'any',\n  /**\n   * Unknown value (must be narrowed before usage).\n   */\n  unknown: 'unknown',\n  /**\n   * No return value (`void`).\n   */\n  void: 'void',\n  /**\n   * Object with named properties.\n   */\n  object: 'object',\n  /**\n   * Sequential list of items.\n   */\n  array: 'array',\n  /**\n   * Fixed-length list with position-specific items.\n   */\n  tuple: 'tuple',\n  /**\n   * \"One of\" multiple schema members.\n   */\n  union: 'union',\n  /**\n   * \"All of\" multiple schema members.\n   */\n  intersection: 'intersection',\n  /**\n   * Enum schema.\n   */\n  enum: 'enum',\n  /**\n   * Reference to another schema.\n   */\n  ref: 'ref',\n  /**\n   * Calendar date (for example `2026-03-24`).\n   */\n  date: 'date',\n  /**\n   * Date-time value (for example `2026-03-24T09:00:00Z`).\n   */\n  datetime: 'datetime',\n  /**\n   * Time-only value (for example `09:00:00`).\n   */\n  time: 'time',\n  /**\n   * UUID value.\n   */\n  uuid: 'uuid',\n  /**\n   * Email address value.\n   */\n  email: 'email',\n  /**\n   * URL value.\n   */\n  url: 'url',\n  /**\n   * IPv4 address value.\n   */\n  ipv4: 'ipv4',\n  /**\n   * IPv6 address value.\n   */\n  ipv6: 'ipv6',\n  /**\n   * Binary/blob value.\n   */\n  blob: 'blob',\n  /**\n   * Impossible value (`never`).\n   */\n  never: 'never',\n} as const satisfies Record<SchemaType, SchemaType>\n\nexport type ScalarPrimitive = 'string' | 'number' | 'integer' | 'bigint' | 'boolean'\n\n/**\n * Scalar primitive schema types used for union simplification and type narrowing.\n */\nconst SCALAR_PRIMITIVE_TYPES = new Set<ScalarPrimitive>(['string', 'number', 'integer', 'bigint', 'boolean'])\n\n/**\n * Returns `true` when `type` is a scalar primitive that can be assigned without wrapping\n * (for example `string | number | boolean`).\n */\nexport function isScalarPrimitive(type: string): type is ScalarPrimitive {\n  return SCALAR_PRIMITIVE_TYPES.has(type as ScalarPrimitive)\n}\n\n/**\n * HTTP method identifiers used by operation nodes.\n */\nexport const httpMethods = {\n  get: 'GET',\n  post: 'POST',\n  put: 'PUT',\n  patch: 'PATCH',\n  delete: 'DELETE',\n  head: 'HEAD',\n  options: 'OPTIONS',\n  trace: 'TRACE',\n} as const satisfies Record<Lowercase<HttpMethod>, HttpMethod>\n\n/**\n * Default concurrency limit for the `walk()` traversal utility.\n *\n * Set to 30 to balance I/O-bound resolver parallelism against event-loop and memory pressure\n * during large spec traversals. Override it for different hardware constraints.\n *\n * @example\n * ```ts\n * import { walk, WALK_CONCURRENCY } from '@kubb/ast'\n *\n * walk(root, { concurrency: WALK_CONCURRENCY, root: () => {} })\n * ```\n */\nexport const WALK_CONCURRENCY = 30\n\n/**\n * Number of spaces in one indentation level when assembling multi-line code as strings.\n * Set to 2, 3, … to change the indent width used by `buildObject`/`buildList`.\n */\nconst INDENT_SIZE = 2\n\n/**\n * One indentation level, derived from {@link INDENT_SIZE}.\n */\nexport const INDENT = Array.from({ length: INDENT_SIZE }, () => ' ').join('')\n","import { hash } from 'node:crypto'\nimport type { SchemaNode } from './nodes/index.ts'\nimport { extractRefName } from './utils/index.ts'\n\n/**\n * The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.\n */\nfunction flagsDescriptor(node: SchemaNode): string {\n  return `${node.primitive ?? ''};${node.format ?? ''};${node.nullable ? 1 : 0}`\n}\n\nfunction refTargetName(node: Extract<SchemaNode, { type: 'ref' }>): string {\n  if (node.ref) return extractRefName(node.ref)\n  return node.name ?? ''\n}\n\ntype ScalarField = { kind: 'scalar'; key: string; prefix: string }\ntype BoolField = { kind: 'bool'; key: string; prefix: string }\ntype ChildField = { kind: 'child'; key: string; prefix: string }\ntype ChildrenField = { kind: 'children'; key: string; prefix: string }\ntype ObjectPropsField = { kind: 'objectProps' }\ntype AdditionalPropsField = { kind: 'additionalProps' }\ntype PatternPropsField = { kind: 'patternProps' }\ntype EnumValuesField = { kind: 'enumValues' }\ntype RefTargetField = { kind: 'refTarget' }\n\ntype ShapeField =\n  | ScalarField\n  | BoolField\n  | ChildField\n  | ChildrenField\n  | ObjectPropsField\n  | AdditionalPropsField\n  | PatternPropsField\n  | EnumValuesField\n  | RefTargetField\n\nconst arrayTupleFields: ReadonlyArray<ShapeField> = [\n  { kind: 'children', key: 'items', prefix: 'i' },\n  { kind: 'child', key: 'rest', prefix: 'r' },\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n  { kind: 'bool', key: 'unique', prefix: 'u' },\n]\n\nconst numericFields: ReadonlyArray<ShapeField> = [\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n  { kind: 'scalar', key: 'exclusiveMinimum', prefix: 'emn' },\n  { kind: 'scalar', key: 'exclusiveMaximum', prefix: 'emx' },\n  { kind: 'scalar', key: 'multipleOf', prefix: 'mo' },\n]\n\nconst rangeFields: ReadonlyArray<ShapeField> = [\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n]\n\n/**\n * Maps each node `type` to its ordered shape-contributing fields. Types absent from the map\n * (boolean, null, any, and other scalars) fall back to `${type}|${flags}`.\n */\nconst SHAPE_KEYS: Partial<Record<SchemaNode['type'], ReadonlyArray<ShapeField>>> = {\n  object: [\n    { kind: 'objectProps' },\n    { kind: 'additionalProps' },\n    { kind: 'patternProps' },\n    { kind: 'scalar', key: 'minProperties', prefix: 'mn' },\n    { kind: 'scalar', key: 'maxProperties', prefix: 'mx' },\n  ],\n  array: arrayTupleFields,\n  tuple: arrayTupleFields,\n  union: [\n    { kind: 'scalar', key: 'strategy', prefix: 's' },\n    { kind: 'scalar', key: 'discriminatorPropertyName', prefix: 'd' },\n    { kind: 'children', key: 'members', prefix: 'm' },\n  ],\n  intersection: [{ kind: 'children', key: 'members', prefix: 'm' }],\n  enum: [{ kind: 'enumValues' }],\n  ref: [{ kind: 'refTarget' }],\n  string: [\n    { kind: 'scalar', key: 'min', prefix: 'mn' },\n    { kind: 'scalar', key: 'max', prefix: 'mx' },\n    { kind: 'scalar', key: 'pattern', prefix: 'pt' },\n  ],\n  number: numericFields,\n  integer: numericFields,\n  bigint: numericFields,\n  url: [\n    { kind: 'scalar', key: 'path', prefix: 'path' },\n    { kind: 'scalar', key: 'min', prefix: 'mn' },\n    { kind: 'scalar', key: 'max', prefix: 'mx' },\n  ],\n  uuid: rangeFields,\n  email: rangeFields,\n  datetime: [\n    { kind: 'bool', key: 'offset', prefix: 'o' },\n    { kind: 'bool', key: 'local', prefix: 'l' },\n  ],\n  date: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],\n  time: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],\n}\n\nfunction serializeShapeField(field: ShapeField, node: SchemaNode, record: Record<string, unknown>): string {\n  switch (field.kind) {\n    case 'scalar':\n      return `${field.prefix}:${record[field.key] ?? ''}`\n    case 'bool':\n      return `${field.prefix}:${record[field.key] ? 1 : 0}`\n    case 'child': {\n      const child = record[field.key] as SchemaNode | undefined\n      return `${field.prefix}:${child ? signatureOf(child) : ''}`\n    }\n    case 'children': {\n      const children = (record[field.key] as Array<SchemaNode> | undefined) ?? []\n      return `${field.prefix}[${children.map((c) => signatureOf(c)).join(',')}]`\n    }\n    case 'objectProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      const props = (obj.properties ?? []).map((prop) => `${prop.name}${prop.required ? '!' : '?'}${signatureOf(prop.schema)}`).join(',')\n      return `p[${props}]`\n    }\n    case 'additionalProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      if (typeof obj.additionalProperties === 'boolean') return `ab:${obj.additionalProperties}`\n      if (obj.additionalProperties) return `as:${signatureOf(obj.additionalProperties)}`\n      return ''\n    }\n    case 'patternProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      const pattern = obj.patternProperties\n        ? Object.keys(obj.patternProperties)\n            .sort()\n            .map((key) => `${key}=${signatureOf(obj.patternProperties![key]!)}`)\n            .join(',')\n        : ''\n      return `pp[${pattern}]`\n    }\n    case 'enumValues': {\n      const en = node as Extract<SchemaNode, { type: 'enum' }>\n      let values = ''\n      if (en.namedEnumValues?.length) {\n        values = en.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(',')\n      } else if (en.enumValues?.length) {\n        values = en.enumValues.map((value) => `${value === null ? 'null' : typeof value}:${String(value)}`).join(',')\n      }\n      return `v[${values}]`\n    }\n    case 'refTarget': {\n      return `->${refTargetName(node as Extract<SchemaNode, { type: 'ref' }>)}`\n    }\n  }\n}\n\n/**\n * Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,\n * constraints, and its children's signatures.\n */\nfunction describeShape(node: SchemaNode): string {\n  const flags = flagsDescriptor(node)\n  const fields = SHAPE_KEYS[node.type]\n  if (!fields) return `${node.type}|${flags}`\n\n  const record = node as unknown as Record<string, unknown>\n  const parts: Array<string> = [`${node.type}|${flags}`]\n  for (const field of fields) {\n    parts.push(serializeShapeField(field, node, record))\n  }\n  return parts.join('|')\n}\n\n/**\n * Caches the digest per node, keyed by identity. A `WeakMap` so entries die with the node, and so\n * a tree hashed during dedupe planning is not walked again when it is rewritten during streaming.\n * Reuse is safe because a signature depends only on content, and nodes are immutable once created.\n */\nconst signatureCache = new WeakMap<SchemaNode, string>()\n\n/**\n * Computes a deterministic, shape-only signature (a content hash) for a schema node. Two schemas\n * share a signature when they are structurally identical, ignoring documentation (`name`, `title`,\n * `description`, `example`, `default`, `deprecated`) and usage-slot flags (`optional`, `nullish`,\n * `readOnly`, `writeOnly`). `nullable` is kept because it changes the produced type, and `ref`\n * nodes compare by target name, which also terminates on circular shapes.\n *\n * @example Two enums with different descriptions share a signature\n * ```ts\n * signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===\n *   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))\n * ```\n */\nexport function signatureOf(node: SchemaNode): string {\n  const cached = signatureCache.get(node)\n  if (cached !== undefined) return cached\n  const signature = hash('sha256', describeShape(node), 'hex')\n  signatureCache.set(node, signature)\n\n  return signature\n}\n\n/**\n * Returns `true` when two schema nodes are structurally identical under shape-only equality,\n * meaning they produce the same TypeScript type.\n */\nexport function isSchemaEqual(a: SchemaNode, b: SchemaNode): boolean {\n  return signatureOf(a) === signatureOf(b)\n}\n","import type { NodeDef } from './node.ts'\nimport { arrowFunctionDef, breakDef, constDef, functionDef, jsxDef, textDef, typeDef } from './nodes/code.ts'\nimport { contentDef } from './nodes/content.ts'\nimport { exportDef, fileDef, importDef, sourceDef } from './nodes/file.ts'\nimport { functionParameterDef, functionParametersDef, indexedAccessTypeDef, objectBindingPatternDef, typeLiteralDef } from './nodes/function.ts'\nimport { inputDef } from './nodes/input.ts'\nimport { operationDef } from './nodes/operation.ts'\nimport { outputDef } from './nodes/output.ts'\nimport { parameterDef } from './nodes/parameter.ts'\nimport { propertyDef } from './nodes/property.ts'\nimport { requestBodyDef } from './nodes/requestBody.ts'\nimport { responseDef } from './nodes/response.ts'\nimport { schemaDef } from './nodes/schema.ts'\n\n// Surface every def from one place so the package barrel re-exports them with `export * from './registry.ts'`.\n// Adding a node means adding its `defineNode` to a `nodes/*.ts` file and listing it in `nodeDefs` below, nothing else.\nexport {\n  arrowFunctionDef,\n  breakDef,\n  constDef,\n  contentDef,\n  exportDef,\n  fileDef,\n  functionDef,\n  functionParameterDef,\n  functionParametersDef,\n  importDef,\n  indexedAccessTypeDef,\n  inputDef,\n  jsxDef,\n  objectBindingPatternDef,\n  operationDef,\n  outputDef,\n  parameterDef,\n  propertyDef,\n  requestBodyDef,\n  responseDef,\n  schemaDef,\n  sourceDef,\n  textDef,\n  typeDef,\n  typeLiteralDef,\n}\n\n/**\n * Every node definition. Adding a node means adding its `defineNode` to one\n * `nodes/*.ts` file and listing it here. The visitor tables in `visitor.ts` derive from it.\n */\nexport const nodeDefs = [\n  inputDef,\n  outputDef,\n  operationDef,\n  requestBodyDef,\n  contentDef,\n  responseDef,\n  schemaDef,\n  propertyDef,\n  parameterDef,\n  functionParameterDef,\n  functionParametersDef,\n  typeLiteralDef,\n  indexedAccessTypeDef,\n  objectBindingPatternDef,\n  constDef,\n  typeDef,\n  functionDef,\n  arrowFunctionDef,\n  textDef,\n  breakDef,\n  jsxDef,\n  importDef,\n  exportDef,\n  sourceDef,\n  fileDef,\n] satisfies ReadonlyArray<NodeDef>\n","import type { VisitorDepth } from './constants.ts'\nimport { visitorDepths, WALK_CONCURRENCY } from './constants.ts'\nimport type { NodeDef } from './node.ts'\nimport type {\n  ContentNode,\n  InputNode,\n  Node,\n  NodeKind,\n  OperationNode,\n  OutputNode,\n  ParameterNode,\n  PropertyNode,\n  RequestBodyNode,\n  ResponseNode,\n  SchemaNode,\n} from './nodes/index.ts'\nimport { nodeDefs } from './registry.ts'\n\n/**\n * Child node fields per node kind, in traversal order (Babel's `VISITOR_KEYS`).\n * Derived from each definition's `children`.\n */\nconst VISITOR_KEYS = Object.fromEntries(nodeDefs.flatMap((def) => (def.children ? [[def.kind, def.children] as const] : []))) as Partial<\n  Record<NodeKind, ReadonlyArray<string>>\n>\n\n/**\n * Maps a node kind to the matching visitor callback name. Derived from each\n * definition's `visitorKey`.\n */\nconst VISITOR_KEY_BY_KIND = Object.fromEntries(nodeDefs.flatMap((def) => (def.visitorKey ? [[def.kind, def.visitorKey] as const] : []))) as Partial<\n  Record<NodeKind, NonNullable<NodeDef['visitorKey']>>\n>\n\n/**\n * Per-kind builders rerun after children are rebuilt. Derived from each\n * definition's `rebuild` flag.\n */\nconst nodeRebuilders = Object.fromEntries(\n  nodeDefs.flatMap((def) => (def.rebuild ? [[def.kind, def.create as unknown as (node: Node) => Node] as const] : [])),\n) as Partial<Record<NodeKind, (node: Node) => Node>>\n\n/**\n * Creates a small async concurrency limiter.\n *\n * At most `concurrency` tasks are in flight at once. Extra tasks are queued.\n *\n * @example\n * ```ts\n * const limit = createLimit(2)\n * for (const task of [taskA, taskB, taskC]) {\n *   await limit(() => task())\n * }\n * // only 2 tasks run at the same time\n * ```\n */\nfunction createLimit(concurrency: number) {\n  let active = 0\n  const queue: Array<() => void> = []\n\n  function next() {\n    if (active < concurrency && queue.length > 0) {\n      active++\n      queue.shift()!()\n    }\n  }\n\n  return function limit<T>(fn: () => Promise<T> | T): Promise<T> {\n    return new Promise<T>((resolve, reject) => {\n      queue.push(() => {\n        Promise.resolve(fn())\n          .then(resolve, reject)\n          .finally(() => {\n            active--\n            next()\n          })\n      })\n      next()\n    })\n  }\n}\n\ntype LimitFn = ReturnType<typeof createLimit>\n\n/**\n * Ordered mapping of `[NodeType, ParentType]` pairs.\n *\n * `ParentOf` uses this map to find parent types.\n */\ntype ParentNodeMap = [\n  [InputNode, undefined],\n  [OutputNode, undefined],\n  [OperationNode, InputNode],\n  [RequestBodyNode, OperationNode],\n  [ContentNode, RequestBodyNode | ResponseNode],\n  [SchemaNode, InputNode | ContentNode | SchemaNode | PropertyNode | ParameterNode],\n  [PropertyNode, SchemaNode],\n  [ParameterNode, OperationNode],\n  [ResponseNode, OperationNode],\n]\n\n/**\n * Resolves the parent node type for a given AST node type.\n *\n * Visitor context relies on this so `ctx.parent` is typed for each callback.\n *\n * @example\n * ```ts\n * type InputParent = ParentOf<InputNode>\n * // undefined\n * ```\n *\n * @example\n * ```ts\n * type PropertyParent = ParentOf<PropertyNode>\n * // SchemaNode\n * ```\n *\n * @example\n * ```ts\n * type SchemaParent = ParentOf<SchemaNode>\n * // InputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode\n * ```\n */\nexport type ParentOf<T extends Node, TEntries extends ReadonlyArray<[Node, unknown]> = ParentNodeMap> = TEntries extends [\n  infer TEntry extends [Node, unknown],\n  ...infer TRest extends ReadonlyArray<[Node, unknown]>,\n]\n  ? T extends TEntry[0]\n    ? TEntry[1]\n    : ParentOf<T, TRest>\n  : Node\n\n/**\n * Traversal context passed as the second argument to every visitor callback.\n * `parent` is typed from the current node type.\n *\n * @example\n * ```ts\n * const visitor: Visitor = {\n *   schema(node, { parent }) {\n *     // parent type is narrowed by node kind\n *   },\n * }\n * ```\n */\nexport type VisitorContext<T extends Node = Node> = {\n  /**\n   * Parent node of the currently visited node.\n   * For `InputNode`, this is `undefined`.\n   */\n  parent?: ParentOf<T>\n}\n\n/**\n * Synchronous visitor consumed by `transform`. Each optional callback runs\n * for the matching node type. Return a new node to replace it, or `undefined`\n * to leave it untouched.\n *\n * Plugins typically expose `transformer` so users can supply a `Visitor` that\n * rewrites the AST before printing.\n *\n * @example Prefix every operationId\n * ```ts\n * const visitor: Visitor = {\n *   operation(node) {\n *     return { ...node, operationId: `api_${node.operationId}` }\n *   },\n * }\n * ```\n *\n * @example Strip schema descriptions\n * ```ts\n * const visitor: Visitor = {\n *   schema(node) {\n *     return { ...node, description: undefined }\n *   },\n * }\n * ```\n */\nexport type Visitor = {\n  input?(node: InputNode, context: VisitorContext<InputNode>): undefined | null | InputNode\n  output?(node: OutputNode, context: VisitorContext<OutputNode>): undefined | null | OutputNode\n  operation?(node: OperationNode, context: VisitorContext<OperationNode>): undefined | null | OperationNode\n  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): undefined | null | SchemaNode\n  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): undefined | null | PropertyNode\n  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): undefined | null | ParameterNode\n  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): undefined | null | ResponseNode\n}\n\n/**\n * A visitor callback result that may be sync or async.\n */\ntype MaybePromise<T> = T | Promise<T>\n\n/**\n * Async visitor for `walk`. Synchronous `Visitor` objects are compatible.\n *\n * @example\n * ```ts\n * const visitor: AsyncVisitor = {\n *   async operation(node) {\n *     await Promise.resolve(node.operationId)\n *   },\n * }\n * ```\n */\ntype AsyncVisitor = {\n  input?(node: InputNode, context: VisitorContext<InputNode>): MaybePromise<undefined | null | InputNode>\n  output?(node: OutputNode, context: VisitorContext<OutputNode>): MaybePromise<undefined | null | OutputNode>\n  operation?(node: OperationNode, context: VisitorContext<OperationNode>): MaybePromise<undefined | null | OperationNode>\n  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): MaybePromise<undefined | null | SchemaNode>\n  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): MaybePromise<undefined | null | PropertyNode>\n  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): MaybePromise<undefined | null | ParameterNode>\n  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): MaybePromise<undefined | null | ResponseNode>\n}\n\n/**\n * Visitor used by `collect`.\n *\n * @example\n * ```ts\n * const visitor: CollectVisitor<string> = {\n *   operation(node) {\n *     return node.operationId\n *   },\n * }\n * ```\n */\ntype CollectVisitor<T> = {\n  input?(node: InputNode, context: VisitorContext<InputNode>): T | null | undefined\n  output?(node: OutputNode, context: VisitorContext<OutputNode>): T | null | undefined\n  operation?(node: OperationNode, context: VisitorContext<OperationNode>): T | null | undefined\n  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): T | null | undefined\n  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): T | null | undefined\n  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): T | null | undefined\n  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): T | null | undefined\n}\n\n/**\n * Options for `transform`.\n *\n * @example\n * ```ts\n * const options: TransformOptions = { depth: 'deep', schema: (node) => node }\n * ```\n *\n * @example\n * ```ts\n * // Only transform the current node, not nested children\n * const options: TransformOptions = { depth: 'shallow', schema: (node) => node }\n * ```\n */\nexport type TransformOptions = Visitor & {\n  /**\n   * Traversal depth.\n   * @default 'deep'\n   */\n  depth?: VisitorDepth\n  /**\n   * Internal parent override used during recursion.\n   */\n  parent?: Node\n}\n\n/**\n * Options for `walk`.\n *\n * @example\n * ```ts\n * const options: WalkOptions = { depth: 'deep', concurrency: 10, root: () => {} }\n * ```\n */\nexport type WalkOptions = AsyncVisitor & {\n  /**\n   * Traversal depth.\n   * @default 'deep'\n   */\n  depth?: VisitorDepth\n  /**\n   * Maximum number of sibling nodes visited concurrently.\n   * @default 30\n   */\n  concurrency?: number\n}\n\n/**\n * Options for `collect`.\n *\n * @example\n * ```ts\n * const options: CollectOptions<string> = { depth: 'shallow', schema: () => undefined }\n * ```\n */\nexport type CollectOptions<T> = CollectVisitor<T> & {\n  /**\n   * Traversal depth.\n   * @default 'deep'\n   */\n  depth?: VisitorDepth\n  /**\n   * Internal parent override used during recursion.\n   */\n  parent?: Node\n}\n\nconst visitorKeysByKind = VISITOR_KEYS as Record<string, ReadonlyArray<string> | undefined>\n\n/**\n * Returns `true` when `value` is an AST node (an object carrying a `kind`).\n */\nfunction isNode(value: unknown): value is Node {\n  return typeof value === 'object' && value !== null && 'kind' in value\n}\n\n/**\n * Returns the immediate traversable children of `node` based on {@link VISITOR_KEYS}.\n *\n * `Schema` children are only included when `recurse` is `true`. Shallow mode skips them.\n *\n * @example\n * ```ts\n * const children = getChildren(operationNode, true)\n * // returns parameters, the request body, and responses\n * ```\n */\nfunction* getChildren(node: Node, recurse: boolean): Generator<Node, void, undefined> {\n  if (node.kind === 'Schema' && !recurse) return\n\n  const keys = visitorKeysByKind[node.kind]\n  if (!keys) return\n\n  const record = node as unknown as Record<string, unknown>\n  for (const key of keys) {\n    const value = record[key]\n    if (Array.isArray(value)) {\n      for (const item of value) if (isNode(item)) yield item\n    } else if (isNode(value)) {\n      yield value\n    }\n  }\n}\n\n/**\n * Runs the visitor callback that matches `node.kind` with the traversal\n * context. The result is a replacement node, a collected value, or `undefined`\n * when no callback is registered for the kind.\n *\n * Shared by `walk`, `transform`, and `collectLazy` so node-kind dispatch lives\n * in one place. `TResult` is the caller's expected return: the same node type\n * for `transform`, the collected value type for `collectLazy`, ignored for `walk`.\n */\nfunction applyVisitor<TResult>(node: Node, visitor: Visitor | AsyncVisitor | CollectVisitor<unknown>, parent: Node | undefined): TResult | null | undefined {\n  const key = VISITOR_KEY_BY_KIND[node.kind]\n  if (!key) return undefined\n\n  const fn = visitor[key] as ((node: Node, context: VisitorContext) => TResult | null | undefined) | undefined\n\n  return fn?.(node, { parent })\n}\n\n/**\n * Async depth-first traversal for side effects. Visitor return values are\n * ignored. Use `transform` when you want to rewrite nodes.\n *\n * Sibling nodes at each depth run concurrently up to `options.concurrency`\n * (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor\n * work. Lower values reduce memory pressure.\n *\n * @example Log every operation\n * ```ts\n * await walk(root, {\n *   operation(node) {\n *     console.log(node.operationId)\n *   },\n * })\n * ```\n *\n * @example Only visit the root node\n * ```ts\n * await walk(root, { depth: 'shallow', input: () => {} })\n * ```\n */\nexport async function walk(node: Node, options: WalkOptions): Promise<void> {\n  const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep\n  const limit = createLimit(options.concurrency ?? WALK_CONCURRENCY)\n\n  return _walk(node, options, recurse, limit, undefined)\n}\n\nasync function _walk(node: Node, visitor: AsyncVisitor, recurse: boolean, limit: LimitFn, parent: Node | undefined): Promise<void> {\n  await limit(() => applyVisitor(node, visitor, parent))\n\n  // Visit siblings concurrently and let the shared `limit` cap how many callbacks\n  // run at once. Awaiting each child sequentially here would serialize the whole\n  // traversal and make `concurrency` inert. Every visitor callback would run one\n  // at a time regardless of the limit.\n  const children = Array.from(getChildren(node, recurse))\n  if (children.length === 0) return\n\n  await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit, node)))\n}\n\n/**\n * Synchronous depth-first transform. Each visitor callback can return a\n * replacement node. Returning `undefined` keeps the original.\n *\n * The original tree is never mutated, a new tree is returned. Pass\n * `depth: 'shallow'` to skip recursion into children.\n *\n * @example Prefix every operationId\n * ```ts\n * const next = transform(root, {\n *   operation(node) {\n *     return { ...node, operationId: `prefixed_${node.operationId}` }\n *   },\n * })\n * ```\n *\n * @example Replace only the root node\n * ```ts\n * const next = transform(root, {\n *   depth: 'shallow',\n *   input: (node) => ({ ...node, meta: { ...node.meta, title: 'Rewritten' } }),\n * })\n * ```\n */\nexport function transform(node: InputNode, options: TransformOptions): InputNode\nexport function transform(node: OutputNode, options: TransformOptions): OutputNode\nexport function transform(node: OperationNode, options: TransformOptions): OperationNode\nexport function transform(node: SchemaNode, options: TransformOptions): SchemaNode\nexport function transform(node: PropertyNode, options: TransformOptions): PropertyNode\nexport function transform(node: ParameterNode, options: TransformOptions): ParameterNode\nexport function transform(node: ResponseNode, options: TransformOptions): ResponseNode\nexport function transform(node: Node, options: TransformOptions): Node\nexport function transform(node: Node, options: TransformOptions): Node {\n  const { depth, parent, ...visitor } = options\n  const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep\n\n  const visited = applyVisitor<Node>(node, visitor, parent) ?? node\n  const rebuilt = transformChildren(visited, options, recurse)\n\n  // Structural sharing: when the visitor and child rebuild both left this node\n  // untouched, return the original reference so callers can detect \"nothing\n  // changed\" by identity and ancestors can avoid reallocating.\n  if (rebuilt === node) return node\n\n  const rebuild = nodeRebuilders[rebuilt.kind]\n  return rebuild ? rebuild(rebuilt) : rebuilt\n}\n\n/**\n * Immutably rebuilds a node's children using {@link VISITOR_KEYS}, transforming\n * each child node and leaving non-node values (e.g. `additionalProperties: true`) intact.\n * `Schema` children are skipped in shallow mode.\n */\nfunction transformChildren(node: Node, options: TransformOptions, recurse: boolean): Node {\n  if (node.kind === 'Schema' && !recurse) return node\n\n  const keys = visitorKeysByKind[node.kind]\n  if (!keys) return node\n\n  const record = node as unknown as Record<string, unknown>\n  const childOptions = { ...options, parent: node }\n  let updates: Record<string, unknown> | undefined\n\n  for (const key of keys) {\n    if (!(key in record)) continue\n    const value = record[key]\n    if (Array.isArray(value)) {\n      let changed = false\n      const mapped = value.map((item) => {\n        if (!isNode(item)) return item\n        const next = transform(item, childOptions)\n        if (next !== item) changed = true\n        return next\n      })\n      if (changed) (updates ??= {})[key] = mapped\n    } else if (isNode(value)) {\n      const next = transform(value, childOptions)\n      if (next !== value) (updates ??= {})[key] = next\n    }\n  }\n\n  return updates ? ({ ...node, ...updates } as Node) : node\n}\n/**\n * Lazy depth-first collection pass. Yields every non-null value returned by\n * the visitor callbacks. Use `collect` for the eager array form.\n *\n * @example Collect every operationId\n * ```ts\n * const ids: string[] = []\n * for (const id of collectLazy<string>(root, {\n *   operation(node) {\n *     return node.operationId\n *   },\n * })) {\n *   ids.push(id)\n * }\n * ```\n */\nexport function* collectLazy<T>(node: Node, options: CollectOptions<T>): Generator<T, void, undefined> {\n  const { depth, parent, ...visitor } = options\n  const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep\n\n  const v = applyVisitor<T>(node, visitor, parent)\n  if (v != null) yield v\n\n  for (const child of getChildren(node, recurse)) {\n    yield* collectLazy(child, { ...options, parent: node })\n  }\n}\n\n/**\n * Eager depth-first collection pass. Gathers every non-null value the visitor\n * callbacks return into an array.\n *\n * @example Collect every operationId\n * ```ts\n * const ids = collect<string>(root, {\n *   operation(node) {\n *     return node.operationId\n *   },\n * })\n * ```\n */\nexport function collect<T>(node: Node, options: CollectOptions<T>): Array<T> {\n  return Array.from(collectLazy(node, options))\n}\n","/**\n * Schema-shape deduplication. `buildDedupePlan` finds top-level and inline schemas that share a\n * structural signature, picks one canonical definition, and `applyDedupe` repoints every duplicate\n * at it. This works on `SchemaNode` content, not on files.\n *\n * For merging a file's imports, exports, and source nodes, see `utils/fileMerge.ts`. Same idea of\n * collapsing duplicates, but a different domain.\n */\nimport type { Node, OperationNode, SchemaNode } from './nodes/index.ts'\nimport { createSchema } from './nodes/schema.ts'\nimport { signatureOf } from './signature.ts'\nimport { extractRefName } from './utils/index.ts'\nimport { collectLazy, transform } from './visitor.ts'\n\n/**\n * A canonical destination for a deduplicated shape: the shared schema name and\n * the synthetic `$ref` path that points at it.\n */\nexport type DedupeCanonical = {\n  /**\n   * Canonical schema name every duplicate occurrence refers to.\n   */\n  name: string\n  /**\n   * `$ref` path stored on the generated `ref` nodes (for example `#/components/schemas/Status`).\n   */\n  ref: string\n}\n\n/**\n * The result of {@link buildDedupePlan}: a lookup from structural signature to its\n * canonical target, plus the freshly hoisted definitions that must be added to\n * the schema list.\n */\nexport type DedupePlan = {\n  /**\n   * Maps a structural signature to the canonical schema that represents it.\n   */\n  canonicalBySignature: Map<string, DedupeCanonical>\n  /**\n   * Maps the name of a top-level schema that duplicates a canonical one to that canonical, so\n   * references to the duplicate can be repointed at the first schema with the same content.\n   */\n  aliasNames: Map<string, DedupeCanonical>\n  /**\n   * New top-level schema definitions created for inline shapes that had no existing\n   * named component. Nested duplicates inside each definition are already collapsed.\n   */\n  hoisted: Array<SchemaNode>\n}\n\n/**\n * The lookups {@link applyDedupe} needs from a {@link DedupePlan}.\n */\nexport type DedupeLookups = Pick<DedupePlan, 'canonicalBySignature' | 'aliasNames'>\n\n/**\n * Options that inject the naming and candidate policy into {@link buildDedupePlan}.\n * The mechanics (grouping, counting, rewriting) live here. The policy lives in the caller.\n */\nexport type BuildDedupePlanOptions = {\n  /**\n   * Returns `true` when a node should be deduplicated. This is the only gate, so it must\n   * reject both ineligible kinds (return `false` for anything other than, say, enums and\n   * objects) and unsafe shapes (e.g. nodes that reference a circular schema).\n   */\n  isCandidate: (node: SchemaNode) => boolean\n  /**\n   * Produces the canonical name for an inline shape with no existing named component.\n   * Return `null` to leave the shape inline (for example when no contextual name exists).\n   */\n  nameFor: (node: SchemaNode, signature: string) => string | null\n  /**\n   * Builds the `$ref` path for a canonical name.\n   */\n  refFor: (name: string) => string\n  /**\n   * Minimum number of occurrences before a shape is deduplicated.\n   *\n   * @default 2\n   */\n  minOccurrences?: number\n}\n\n/**\n * Builds the shared `ref` replacement for a duplicate occurrence, carrying the\n * usage-slot and documentation fields that are not part of the canonical type.\n */\nfunction createRefNode(node: SchemaNode, canonical: DedupeCanonical): SchemaNode {\n  return createSchema({\n    type: 'ref',\n    name: canonical.name,\n    ref: canonical.ref,\n    optional: node.optional,\n    nullish: node.nullish,\n    readOnly: node.readOnly,\n    writeOnly: node.writeOnly,\n    deprecated: node.deprecated,\n    description: node.description,\n    default: node.default,\n    example: node.example,\n  })\n}\n\n/**\n * Rewrites a node, replacing every candidate sub-schema whose signature has a canonical\n * target with a `ref` to that target. Replacing a node with a `ref` prunes its subtree,\n * so nested duplicates inside a replaced shape are not visited again. A `ref` that points\n * at a duplicate top-level schema (see `aliasNames`) is repointed at the first schema with\n * the same content.\n *\n * Pass `skipRootMatch` when rewriting a canonical definition so its own root is not\n * turned into a reference to itself. Nested duplicates are still collapsed.\n *\n * @example\n * ```ts\n * const next = applyDedupe(operationNode, plan)\n * ```\n */\nexport function applyDedupe(node: SchemaNode, plan: DedupeLookups, skipRootMatch?: boolean): SchemaNode\nexport function applyDedupe(node: OperationNode, plan: DedupeLookups, skipRootMatch?: boolean): OperationNode\nexport function applyDedupe(node: Node, plan: DedupeLookups, skipRootMatch = false): Node {\n  const { canonicalBySignature, aliasNames } = plan\n  if (canonicalBySignature.size === 0 && aliasNames.size === 0) return node\n\n  const root = node\n\n  return transform(node, {\n    schema(schemaNode) {\n      if (schemaNode.type === 'ref') {\n        const target = schemaNode.ref ? extractRefName(schemaNode.ref) : schemaNode.name\n        const canonical = target ? aliasNames.get(target) : undefined\n\n        return canonical ? { ...schemaNode, name: canonical.name, ref: canonical.ref } : undefined\n      }\n\n      const signature = signatureOf(schemaNode)\n      if (skipRootMatch && schemaNode === root) return undefined\n\n      const canonical = canonicalBySignature.get(signature)\n      if (!canonical) return undefined\n\n      return createRefNode(schemaNode, canonical)\n    },\n  })\n}\n\n/**\n * Strips usage-slot flags from a hoisted definition and applies its canonical name.\n * A standalone definition is never optional, so `optional`/`nullish` are cleared.\n */\nfunction cleanDefinition(node: SchemaNode, name: string): SchemaNode {\n  return { ...node, name, optional: undefined, nullish: undefined }\n}\n\n/**\n * Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.\n *\n * A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence\n * is a named top-level schema, the first one becomes the canonical (so other top-level\n * duplicates and inline copies turn into references to it). Every other top-level name with\n * the same content is recorded in `aliasNames`, so refs to it can be repointed at the\n * canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied\n * per node with {@link applyDedupe}.\n *\n * @example\n * ```ts\n * const plan = buildDedupePlan([...schemaNodes, ...operationNodes], {\n *   isCandidate: (node) => node.type === 'enum' || node.type === 'object',\n *   nameFor: (node) => node.name ?? null,\n *   refFor: (name) => `#/components/schemas/${name}`,\n * })\n * ```\n */\nexport function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupePlanOptions): DedupePlan {\n  const { isCandidate, nameFor, refFor, minOccurrences = 2 } = options\n\n  const topLevelNodes = new Set<SchemaNode>()\n\n  type Group = {\n    count: number\n    representative: SchemaNode\n    topLevelNames: Array<string>\n  }\n  const groups = new Map<string, Group>()\n\n  function record(schemaNode: SchemaNode): void {\n    const signature = signatureOf(schemaNode)\n    if (!isCandidate(schemaNode)) return\n\n    const isTopLevel = topLevelNodes.has(schemaNode) && !!schemaNode.name\n    const group = groups.get(signature)\n    if (group) {\n      group.count++\n      if (isTopLevel) group.topLevelNames.push(schemaNode.name!)\n    } else {\n      groups.set(signature, { count: 1, representative: schemaNode, topLevelNames: isTopLevel ? [schemaNode.name!] : [] })\n    }\n  }\n\n  for (const root of roots) {\n    if (root.kind === 'Schema') topLevelNodes.add(root)\n    for (const schemaNode of collectLazy<SchemaNode>(root, { schema: (node) => node })) {\n      record(schemaNode)\n    }\n  }\n\n  const canonicalBySignature = new Map<string, DedupeCanonical>()\n  const aliasNames = new Map<string, DedupeCanonical>()\n  const pendingHoists: Array<{ name: string; representative: SchemaNode }> = []\n\n  for (const [signature, group] of groups) {\n    if (group.count < minOccurrences) continue\n\n    const [firstName, ...duplicateNames] = group.topLevelNames\n    if (firstName) {\n      const canonical: DedupeCanonical = { name: firstName, ref: refFor(firstName) }\n      canonicalBySignature.set(signature, canonical)\n      for (const duplicate of duplicateNames) {\n        aliasNames.set(duplicate, canonical)\n      }\n      continue\n    }\n\n    const name = nameFor(group.representative, signature)\n    if (!name) continue\n\n    canonicalBySignature.set(signature, { name, ref: refFor(name) })\n    pendingHoists.push({ name, representative: group.representative })\n  }\n\n  // Build hoisted definitions only after every canonical name is known, so nested\n  // duplicates inside a definition also resolve to refs.\n  const hoisted = pendingHoists.map(({ name, representative }) =>\n    cleanDefinition(applyDedupe(representative, { canonicalBySignature, aliasNames }, true), name),\n  )\n\n  return { canonicalBySignature, aliasNames, hoisted }\n}\n","/**\n * The spec-specific questions a schema parser answers while turning a source document into Kubb\n * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where\n * OpenAPI, AsyncAPI, and plain JSON Schema differ.\n */\nexport type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {\n  /**\n   * Identifies the dialect in logs and diagnostics.\n   */\n  name: string\n  /**\n   * Whether the schema is nullable.\n   */\n  isNullable: (schema?: TSchema) => boolean\n  /**\n   * Whether the value is a `$ref` pointer.\n   */\n  isReference: (value?: unknown) => value is TRef\n  /**\n   * Whether the schema carries a discriminator for polymorphism.\n   */\n  isDiscriminator: (value?: unknown) => value is TDiscriminated\n  /**\n   * Whether the schema is binary data, converted to a `blob` node.\n   */\n  isBinary: (schema: TSchema) => boolean\n  /**\n   * Resolves a local `$ref` against the document, or nullish when it cannot.\n   */\n  resolveRef: <TResolved>(document: TDocument, ref: string) => TResolved | null | undefined\n}\n\n/**\n * Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the\n * dialect's type for inference.\n *\n * @example\n * ```ts\n * export const oasDialect = defineSchemaDialect({\n *   name: 'oas',\n *   isNullable,\n *   isReference,\n *   isDiscriminator,\n *   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',\n *   resolveRef,\n * })\n * ```\n */\nexport function defineSchemaDialect<TSchema, TRef, TDiscriminated, TDocument>(\n  dialect: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>,\n): SchemaDialect<TSchema, TRef, TDiscriminated, TDocument> {\n  return dialect\n}\n","import type { SchemaNode, SchemaNodeByType, SchemaType } from './nodes/index.ts'\n\n/**\n * Runtime context passed as `this` to printer handlers.\n *\n * `this.transform` dispatches to node-level handlers from `nodes`.\n *\n * @example\n * ```ts\n * const context: PrinterHandlerContext<string, {}> = {\n *   options: {},\n *   transform: () => 'value',\n * }\n * ```\n */\ntype PrinterHandlerContext<TOutput, TOptions extends object> = {\n  /**\n   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.\n   * Use `this.transform` inside `nodes` handlers and inside the `print` override.\n   */\n  transform: (node: SchemaNode) => TOutput | null\n  /**\n   * Options for this printer instance.\n   */\n  options: TOptions\n}\n\n/**\n * Handler for one schema node type.\n *\n * Use a regular function (not an arrow function) if you need `this`.\n *\n * @example\n * ```ts\n * const handler: PrinterHandler<string, {}, 'string'> = function () {\n *   return 'string'\n * }\n * ```\n */\ntype PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (\n  this: PrinterHandlerContext<TOutput, TOptions>,\n  node: SchemaNodeByType[T],\n) => TOutput | null\n\n/**\n * Partial map of per-node-type handler overrides for a printer.\n *\n * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).\n * Supply only the handlers you want to replace. The printer's built-in\n * defaults fill in the rest.\n *\n * @example\n * ```ts\n * pluginZod({\n *   printer: {\n *     nodes: {\n *       date(): string {\n *         return 'z.string().date()'\n *       },\n *     } satisfies PrinterPartial<string, PrinterZodOptions>,\n *   },\n * })\n * ```\n */\nexport type PrinterPartial<TOutput, TOptions extends object> = Partial<{\n  [K in SchemaType]: PrinterHandler<TOutput, TOptions, K>\n}>\n\n/**\n * Generic shape used by `definePrinter`.\n *\n * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)\n * - `TOptions` options passed to and stored on the printer instance\n * - `TOutput` the type emitted by node handlers\n * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)\n *\n * @example\n * ```ts\n * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>\n * ```\n */\nexport type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {\n  name: TName\n  options: TOptions\n  output: TOutput\n  printOutput: TPrintOutput\n}\n\n/**\n * Printer instance returned by a printer factory.\n *\n * @example\n * ```ts\n * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})\n * ```\n */\nexport type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {\n  /**\n   * Unique identifier supplied at creation time.\n   */\n  name: T['name']\n  /**\n   * Options for this printer instance.\n   */\n  options: T['options']\n  /**\n   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.\n   * Always dispatches through the `nodes` map. Never calls the `print` override.\n   * Reach for it when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.\n   */\n  transform: (node: SchemaNode) => T['output'] | null\n  /**\n   * Public printer. If the builder provides a root-level `print`, this calls that\n   * higher-level function (which may produce full declarations).\n   * Otherwise, falls back to the node-level dispatcher.\n   */\n  print: (node: SchemaNode) => T['printOutput'] | null\n}\n\n/**\n * Builder function passed to `definePrinter`.\n *\n * It receives resolved options and returns:\n * - `name`\n * - `options`\n * - `nodes` handlers\n * - optional top-level `print` override\n *\n * @example\n * ```ts\n * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })\n * ```\n */\ntype PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {\n  name: T['name']\n  /**\n   * Options to store on the printer.\n   */\n  options: T['options']\n  nodes: Partial<{\n    [K in SchemaType]: PrinterHandler<T['output'], T['options'], K>\n  }>\n  /**\n   * Optional root-level print override. When provided, becomes the public `printer.print`.\n   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),\n   * not the override itself, so recursion is safe.\n   */\n  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null\n}\n/**\n * Defines a schema printer: a function that takes a `SchemaNode` and emits\n * code in your target language. Each plugin that produces code from schemas\n * (TypeScript types, Zod schemas, Faker factories) ships a printer built\n * with this helper.\n *\n * The builder receives resolved options and returns:\n *\n * - `name` unique identifier for the printer.\n * - `options` stored on the returned printer instance.\n * - `nodes` map of `SchemaType` → handler. Handlers return the rendered\n *   output (a string, a TypeScript AST node, ...) for that schema type.\n * - `print` (optional), top-level override exposed as `printer.print`.\n *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.\n *\n * Without a `print` override, `printer.print` falls back to `printer.transform`\n * (the node-level dispatcher).\n *\n * @example Tiny Zod printer\n * ```ts\n * import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'\n *\n * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>\n *\n * export const zodPrinter = definePrinter<PrinterZod>((options) => ({\n *   name: 'zod',\n *   options: { strict: options.strict ?? true },\n *   nodes: {\n *     string: () => 'z.string()',\n *     object(node) {\n *       const props = node.properties\n *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)\n *         .join(', ')\n *       return `z.object({ ${props} })`\n *     },\n *   },\n * }))\n * ```\n */\nexport function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T> {\n  return createPrinterFactory<SchemaNode, SchemaType, SchemaNodeByType>((node) => node.type)(build) as (options?: T['options']) => Printer<T>\n}\n\n/**\n * Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.\n *\n * @example\n * ```ts\n * export const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionParamKind, Partial<Record<FunctionParamKind, FunctionParamNode>>>(\n *   (node) => node.kind,\n * )\n * ```\n */\nexport function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | null) {\n  return function <T extends PrinterFactoryOptions>(\n    build: (options: T['options']) => {\n      name: T['name']\n      options: T['options']\n      nodes: Partial<{\n        [K in TKey]: (\n          this: {\n            transform: (node: TNode) => T['output'] | null\n            options: T['options']\n          },\n          node: TNodeByKey[K],\n        ) => T['output'] | null\n      }>\n      print?: (\n        this: {\n          transform: (node: TNode) => T['output'] | null\n          options: T['options']\n        },\n        node: TNode,\n      ) => T['printOutput'] | null\n    },\n  ): (options?: T['options']) => {\n    name: T['name']\n    options: T['options']\n    transform: (node: TNode) => T['output'] | null\n    print: (node: TNode) => T['printOutput'] | null\n  } {\n    return (options) => {\n      const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? ({} as T['options']))\n\n      const context = {\n        options: resolvedOptions,\n        transform: (node: TNode): T['output'] | null => {\n          const key = getKey(node)\n          if (key === null) return null\n\n          const handler = nodes[key]\n\n          if (!handler) return null\n\n          return (handler as (this: typeof context, node: TNode) => T['output'] | null).call(context, node)\n        },\n      }\n\n      return {\n        name,\n        options: resolvedOptions,\n        transform: context.transform,\n        print: (printOverride ? printOverride.bind(context) : context.transform) as (node: TNode) => T['printOutput'] | null,\n      }\n    }\n  }\n}\n","import { isScalarPrimitive } from './constants.ts'\nimport { narrowSchema } from './guards.ts'\nimport { createProperty } from './nodes/property.ts'\nimport { createSchema, type SchemaNode } from './nodes/schema.ts'\nimport { enumPropName } from './utils/refs.ts'\n\n/**\n * Replaces a discriminator property's schema with a string enum of allowed values.\n *\n * If `node` is not an object schema, or if the property does not exist, the input\n * node is returned as-is.\n *\n * @example\n * ```ts\n * const schema = createSchema({\n *   type: 'object',\n *   properties: [createProperty({ name: 'type', required: true, schema: createSchema({ type: 'string' }) })],\n * })\n * const result = setDiscriminatorEnum({ node: schema, propertyName: 'type', values: ['dog', 'cat'] })\n * ```\n */\nexport function setDiscriminatorEnum({\n  node,\n  propertyName,\n  values,\n  enumName,\n}: {\n  node: SchemaNode\n  propertyName: string\n  values: Array<string>\n  enumName?: string\n}): SchemaNode {\n  const objectNode = narrowSchema(node, 'object')\n  if (!objectNode?.properties?.length) {\n    return node\n  }\n\n  const hasProperty = objectNode.properties.some((prop) => prop.name === propertyName)\n  if (!hasProperty) {\n    return node\n  }\n\n  return createSchema({\n    ...objectNode,\n    properties: objectNode.properties.map((prop) => {\n      if (prop.name !== propertyName) {\n        return prop\n      }\n\n      return createProperty({\n        ...prop,\n        schema: createSchema({\n          type: 'enum',\n          primitive: 'string',\n          enumValues: values,\n          name: enumName,\n          readOnly: prop.schema.readOnly,\n          writeOnly: prop.schema.writeOnly,\n        }),\n      })\n    }),\n  })\n}\n\n/**\n * Merges adjacent anonymous object members into a single anonymous object member.\n *\n * @example\n * ```ts\n * const merged = mergeAdjacentObjects([\n *   createSchema({ type: 'object', properties: [createProperty({ name: 'a', schema: createSchema({ type: 'string' }) })] }),\n *   createSchema({ type: 'object', properties: [createProperty({ name: 'b', schema: createSchema({ type: 'number' }) })] }),\n * ])\n * ```\n */\nexport function* mergeAdjacentObjectsLazy(members: Iterable<SchemaNode>): Generator<SchemaNode, void, undefined> {\n  let acc: SchemaNode | undefined\n\n  for (const member of members) {\n    const objectMember = narrowSchema(member, 'object')\n    if (objectMember && !objectMember.name && acc !== undefined) {\n      const accObject = narrowSchema(acc, 'object')\n      if (accObject && !accObject.name) {\n        acc = createSchema({\n          ...accObject,\n          properties: [...(accObject.properties ?? []), ...(objectMember.properties ?? [])],\n        })\n        continue\n      }\n    }\n    if (acc !== undefined) yield acc\n    acc = member\n  }\n\n  if (acc !== undefined) yield acc\n}\n\nexport function mergeAdjacentObjects(members: Array<SchemaNode>): Array<SchemaNode> {\n  return [...mergeAdjacentObjectsLazy(members)]\n}\n\n/**\n * Removes enum members that are covered by broader scalar primitives in the same union.\n *\n * @example\n * ```ts\n * const simplified = simplifyUnion([\n *   createSchema({ type: 'enum', primitive: 'string', enumValues: ['active'] }),\n *   createSchema({ type: 'string' }),\n * ])\n * // keeps only string member\n * ```\n */\nexport function simplifyUnion(members: Array<SchemaNode>): Array<SchemaNode> {\n  const scalarPrimitives = new Set(members.filter((member) => isScalarPrimitive(member.type)).map((m) => m.type))\n\n  if (!scalarPrimitives.size) {\n    return members\n  }\n\n  return members.filter((member) => {\n    const enumNode = narrowSchema(member, 'enum')\n    if (!enumNode) {\n      return true\n    }\n\n    const primitive = enumNode.primitive\n    if (!primitive) {\n      return true\n    }\n\n    const enumValueCount = enumNode.namedEnumValues?.length ?? enumNode.enumValues?.length ?? 0\n    if (enumValueCount <= 1) {\n      return true\n    }\n\n    if (scalarPrimitives.has(primitive)) {\n      return false\n    }\n\n    if ((primitive === 'integer' || primitive === 'number') && (scalarPrimitives.has('integer') || scalarPrimitives.has('number'))) {\n      return false\n    }\n\n    return true\n  })\n}\n\nexport function setEnumName(propNode: SchemaNode, parentName: string | null | undefined, propName: string, enumSuffix: string): SchemaNode {\n  const enumNode = narrowSchema(propNode, 'enum')\n\n  if (enumNode?.primitive === 'boolean') {\n    return { ...propNode, name: null }\n  }\n\n  if (enumNode) {\n    return {\n      ...propNode,\n      name: enumPropName(parentName, propName, enumSuffix),\n    }\n  }\n\n  return propNode\n}\n\n/**\n * Merges a ref node with its resolved schema, giving usage-site fields precedence.\n *\n * Usage-site fields (`description`, `readOnly`, `nullable`, `deprecated`) on the ref node override\n * the same fields in the resolved `node.schema`. Non-ref nodes are returned unchanged.\n *\n * @example\n * ```ts\n * // Ref with description override\n * const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })\n * const merged = syncSchemaRef(ref)  // merges with resolved Pet schema\n * ```\n */\nexport function syncSchemaRef(node: SchemaNode): SchemaNode {\n  const ref = narrowSchema(node, 'ref')\n\n  if (!ref) return node\n  if (!ref.schema) return node\n\n  const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref\n\n  // Filter out undefined override values so they don't shadow the resolved schema's fields.\n  const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== undefined))\n\n  return createSchema({ ...ref.schema, ...definedOverrides })\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.cjs","names":["extractRefName","obj","createSchema","transform","extractRefName","collectLazy"],"sources":["../src/signature.ts","../src/dedupe.ts","../src/dialect.ts","../src/printer.ts"],"sourcesContent":["import { hash } from 'node:crypto'\nimport type { SchemaNode } from './nodes/index.ts'\nimport { extractRefName } from './utils/index.ts'\n\n/**\n * The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.\n */\nfunction flagsDescriptor(node: SchemaNode): string {\n  return `${node.primitive ?? ''};${node.format ?? ''};${node.nullable ? 1 : 0}`\n}\n\nfunction refTargetName(node: Extract<SchemaNode, { type: 'ref' }>): string {\n  if (node.ref) return extractRefName(node.ref)\n  return node.name ?? ''\n}\n\ntype ScalarField = { kind: 'scalar'; key: string; prefix: string }\ntype BoolField = { kind: 'bool'; key: string; prefix: string }\ntype ChildField = { kind: 'child'; key: string; prefix: string }\ntype ChildrenField = { kind: 'children'; key: string; prefix: string }\ntype ObjectPropsField = { kind: 'objectProps' }\ntype AdditionalPropsField = { kind: 'additionalProps' }\ntype PatternPropsField = { kind: 'patternProps' }\ntype EnumValuesField = { kind: 'enumValues' }\ntype RefTargetField = { kind: 'refTarget' }\n\ntype ShapeField =\n  | ScalarField\n  | BoolField\n  | ChildField\n  | ChildrenField\n  | ObjectPropsField\n  | AdditionalPropsField\n  | PatternPropsField\n  | EnumValuesField\n  | RefTargetField\n\nconst arrayTupleFields: ReadonlyArray<ShapeField> = [\n  { kind: 'children', key: 'items', prefix: 'i' },\n  { kind: 'child', key: 'rest', prefix: 'r' },\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n  { kind: 'bool', key: 'unique', prefix: 'u' },\n]\n\nconst numericFields: ReadonlyArray<ShapeField> = [\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n  { kind: 'scalar', key: 'exclusiveMinimum', prefix: 'emn' },\n  { kind: 'scalar', key: 'exclusiveMaximum', prefix: 'emx' },\n  { kind: 'scalar', key: 'multipleOf', prefix: 'mo' },\n]\n\nconst rangeFields: ReadonlyArray<ShapeField> = [\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n]\n\n/**\n * Maps each node `type` to its ordered shape-contributing fields. Types absent from the map\n * (boolean, null, any, and other scalars) fall back to `${type}|${flags}`.\n */\nconst SHAPE_KEYS: Partial<Record<SchemaNode['type'], ReadonlyArray<ShapeField>>> = {\n  object: [\n    { kind: 'objectProps' },\n    { kind: 'additionalProps' },\n    { kind: 'patternProps' },\n    { kind: 'scalar', key: 'minProperties', prefix: 'mn' },\n    { kind: 'scalar', key: 'maxProperties', prefix: 'mx' },\n  ],\n  array: arrayTupleFields,\n  tuple: arrayTupleFields,\n  union: [\n    { kind: 'scalar', key: 'strategy', prefix: 's' },\n    { kind: 'scalar', key: 'discriminatorPropertyName', prefix: 'd' },\n    { kind: 'children', key: 'members', prefix: 'm' },\n  ],\n  intersection: [{ kind: 'children', key: 'members', prefix: 'm' }],\n  enum: [{ kind: 'enumValues' }],\n  ref: [{ kind: 'refTarget' }],\n  string: [\n    { kind: 'scalar', key: 'min', prefix: 'mn' },\n    { kind: 'scalar', key: 'max', prefix: 'mx' },\n    { kind: 'scalar', key: 'pattern', prefix: 'pt' },\n  ],\n  number: numericFields,\n  integer: numericFields,\n  bigint: numericFields,\n  url: [\n    { kind: 'scalar', key: 'path', prefix: 'path' },\n    { kind: 'scalar', key: 'min', prefix: 'mn' },\n    { kind: 'scalar', key: 'max', prefix: 'mx' },\n  ],\n  uuid: rangeFields,\n  email: rangeFields,\n  datetime: [\n    { kind: 'bool', key: 'offset', prefix: 'o' },\n    { kind: 'bool', key: 'local', prefix: 'l' },\n  ],\n  date: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],\n  time: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],\n}\n\nfunction serializeShapeField(field: ShapeField, node: SchemaNode, record: Record<string, unknown>): string {\n  switch (field.kind) {\n    case 'scalar':\n      return `${field.prefix}:${record[field.key] ?? ''}`\n    case 'bool':\n      return `${field.prefix}:${record[field.key] ? 1 : 0}`\n    case 'child': {\n      const child = record[field.key] as SchemaNode | undefined\n      return `${field.prefix}:${child ? signatureOf(child) : ''}`\n    }\n    case 'children': {\n      const children = (record[field.key] as Array<SchemaNode> | undefined) ?? []\n      return `${field.prefix}[${children.map((c) => signatureOf(c)).join(',')}]`\n    }\n    case 'objectProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      const props = (obj.properties ?? []).map((prop) => `${prop.name}${prop.required ? '!' : '?'}${signatureOf(prop.schema)}`).join(',')\n      return `p[${props}]`\n    }\n    case 'additionalProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      if (typeof obj.additionalProperties === 'boolean') return `ab:${obj.additionalProperties}`\n      if (obj.additionalProperties) return `as:${signatureOf(obj.additionalProperties)}`\n      return ''\n    }\n    case 'patternProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      const pattern = obj.patternProperties\n        ? Object.keys(obj.patternProperties)\n            .sort()\n            .map((key) => `${key}=${signatureOf(obj.patternProperties![key]!)}`)\n            .join(',')\n        : ''\n      return `pp[${pattern}]`\n    }\n    case 'enumValues': {\n      const en = node as Extract<SchemaNode, { type: 'enum' }>\n      let values = ''\n      if (en.namedEnumValues?.length) {\n        values = en.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(',')\n      } else if (en.enumValues?.length) {\n        values = en.enumValues.map((value) => `${value === null ? 'null' : typeof value}:${String(value)}`).join(',')\n      }\n      return `v[${values}]`\n    }\n    case 'refTarget': {\n      return `->${refTargetName(node as Extract<SchemaNode, { type: 'ref' }>)}`\n    }\n  }\n}\n\n/**\n * Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,\n * constraints, and its children's signatures.\n */\nfunction describeShape(node: SchemaNode): string {\n  const flags = flagsDescriptor(node)\n  const fields = SHAPE_KEYS[node.type]\n  if (!fields) return `${node.type}|${flags}`\n\n  const record = node as unknown as Record<string, unknown>\n  const parts: Array<string> = [`${node.type}|${flags}`]\n  for (const field of fields) {\n    parts.push(serializeShapeField(field, node, record))\n  }\n  return parts.join('|')\n}\n\n/**\n * Caches the digest per node, keyed by identity. A `WeakMap` so entries die with the node, and so\n * a tree hashed during dedupe planning is not walked again when it is rewritten during streaming.\n * Reuse is safe because a signature depends only on content, and nodes are immutable once created.\n */\nconst signatureCache = new WeakMap<SchemaNode, string>()\n\n/**\n * Computes a deterministic, shape-only signature (a content hash) for a schema node. Two schemas\n * share a signature when they are structurally identical, ignoring documentation (`name`, `title`,\n * `description`, `example`, `default`, `deprecated`) and usage-slot flags (`optional`, `nullish`,\n * `readOnly`, `writeOnly`). `nullable` is kept because it changes the produced type, and `ref`\n * nodes compare by target name, which also terminates on circular shapes.\n *\n * @example Two enums with different descriptions share a signature\n * ```ts\n * signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===\n *   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))\n * ```\n */\nexport function signatureOf(node: SchemaNode): string {\n  const cached = signatureCache.get(node)\n  if (cached !== undefined) return cached\n  const signature = hash('sha256', describeShape(node), 'hex')\n  signatureCache.set(node, signature)\n\n  return signature\n}\n\n/**\n * Returns `true` when two schema nodes are structurally identical under shape-only equality,\n * meaning they produce the same TypeScript type.\n */\nexport function isSchemaEqual(a: SchemaNode, b: SchemaNode): boolean {\n  return signatureOf(a) === signatureOf(b)\n}\n","/**\n * Schema-shape deduplication. `buildDedupePlan` finds top-level and inline schemas that share a\n * structural signature, picks one canonical definition, and `applyDedupe` repoints every duplicate\n * at it. This works on `SchemaNode` content, not on files.\n *\n * For merging a file's imports, exports, and source nodes, see `utils/fileMerge.ts`. Same idea of\n * collapsing duplicates, but a different domain.\n */\nimport type { Node, OperationNode, SchemaNode } from './nodes/index.ts'\nimport { createSchema } from './nodes/schema.ts'\nimport { signatureOf } from './signature.ts'\nimport { extractRefName } from './utils/index.ts'\nimport { collectLazy, transform } from './visitor.ts'\n\n/**\n * A canonical destination for a deduplicated shape: the shared schema name and\n * the synthetic `$ref` path that points at it.\n */\nexport type DedupeCanonical = {\n  /**\n   * Canonical schema name every duplicate occurrence refers to.\n   */\n  name: string\n  /**\n   * `$ref` path stored on the generated `ref` nodes (for example `#/components/schemas/Status`).\n   */\n  ref: string\n}\n\n/**\n * The result of {@link buildDedupePlan}: a lookup from structural signature to its\n * canonical target, plus the freshly hoisted definitions that must be added to\n * the schema list.\n */\nexport type DedupePlan = {\n  /**\n   * Maps a structural signature to the canonical schema that represents it.\n   */\n  canonicalBySignature: Map<string, DedupeCanonical>\n  /**\n   * Maps the name of a top-level schema that duplicates a canonical one to that canonical, so\n   * references to the duplicate can be repointed at the first schema with the same content.\n   */\n  aliasNames: Map<string, DedupeCanonical>\n  /**\n   * New top-level schema definitions created for inline shapes that had no existing\n   * named component. Nested duplicates inside each definition are already collapsed.\n   */\n  hoisted: Array<SchemaNode>\n}\n\n/**\n * The lookups {@link applyDedupe} needs from a {@link DedupePlan}.\n */\nexport type DedupeLookups = Pick<DedupePlan, 'canonicalBySignature' | 'aliasNames'>\n\n/**\n * Options that inject the naming and candidate policy into {@link buildDedupePlan}.\n * The mechanics (grouping, counting, rewriting) live here. The policy lives in the caller.\n */\nexport type BuildDedupePlanOptions = {\n  /**\n   * Returns `true` when a node should be deduplicated. This is the only gate, so it must\n   * reject both ineligible kinds (return `false` for anything other than, say, enums and\n   * objects) and unsafe shapes (e.g. nodes that reference a circular schema).\n   */\n  isCandidate: (node: SchemaNode) => boolean\n  /**\n   * Produces the canonical name for an inline shape with no existing named component.\n   * Return `null` to leave the shape inline (for example when no contextual name exists).\n   */\n  nameFor: (node: SchemaNode, signature: string) => string | null\n  /**\n   * Builds the `$ref` path for a canonical name.\n   */\n  refFor: (name: string) => string\n  /**\n   * Minimum number of occurrences before a shape is deduplicated.\n   *\n   * @default 2\n   */\n  minOccurrences?: number\n}\n\n/**\n * Builds the shared `ref` replacement for a duplicate occurrence, carrying the\n * usage-slot and documentation fields that are not part of the canonical type.\n */\nfunction createRefNode(node: SchemaNode, canonical: DedupeCanonical): SchemaNode {\n  return createSchema({\n    type: 'ref',\n    name: canonical.name,\n    ref: canonical.ref,\n    optional: node.optional,\n    nullish: node.nullish,\n    readOnly: node.readOnly,\n    writeOnly: node.writeOnly,\n    deprecated: node.deprecated,\n    description: node.description,\n    default: node.default,\n    example: node.example,\n  })\n}\n\n/**\n * Rewrites a node, replacing every candidate sub-schema whose signature has a canonical\n * target with a `ref` to that target. Replacing a node with a `ref` prunes its subtree,\n * so nested duplicates inside a replaced shape are not visited again. A `ref` that points\n * at a duplicate top-level schema (see `aliasNames`) is repointed at the first schema with\n * the same content.\n *\n * Pass `skipRootMatch` when rewriting a canonical definition so its own root is not\n * turned into a reference to itself. Nested duplicates are still collapsed.\n *\n * @example\n * ```ts\n * const next = applyDedupe(operationNode, plan)\n * ```\n */\nexport function applyDedupe(node: SchemaNode, plan: DedupeLookups, skipRootMatch?: boolean): SchemaNode\nexport function applyDedupe(node: OperationNode, plan: DedupeLookups, skipRootMatch?: boolean): OperationNode\nexport function applyDedupe(node: Node, plan: DedupeLookups, skipRootMatch = false): Node {\n  const { canonicalBySignature, aliasNames } = plan\n  if (canonicalBySignature.size === 0 && aliasNames.size === 0) return node\n\n  const root = node\n\n  return transform(node, {\n    schema(schemaNode) {\n      if (schemaNode.type === 'ref') {\n        const target = schemaNode.ref ? extractRefName(schemaNode.ref) : schemaNode.name\n        const canonical = target ? aliasNames.get(target) : undefined\n\n        return canonical ? { ...schemaNode, name: canonical.name, ref: canonical.ref } : undefined\n      }\n\n      const signature = signatureOf(schemaNode)\n      if (skipRootMatch && schemaNode === root) return undefined\n\n      const canonical = canonicalBySignature.get(signature)\n      if (!canonical) return undefined\n\n      return createRefNode(schemaNode, canonical)\n    },\n  })\n}\n\n/**\n * Strips usage-slot flags from a hoisted definition and applies its canonical name.\n * A standalone definition is never optional, so `optional`/`nullish` are cleared.\n */\nfunction cleanDefinition(node: SchemaNode, name: string): SchemaNode {\n  return { ...node, name, optional: undefined, nullish: undefined }\n}\n\n/**\n * Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.\n *\n * A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence\n * is a named top-level schema, the first one becomes the canonical (so other top-level\n * duplicates and inline copies turn into references to it). Every other top-level name with\n * the same content is recorded in `aliasNames`, so refs to it can be repointed at the\n * canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied\n * per node with {@link applyDedupe}.\n *\n * @example\n * ```ts\n * const plan = buildDedupePlan([...schemaNodes, ...operationNodes], {\n *   isCandidate: (node) => node.type === 'enum' || node.type === 'object',\n *   nameFor: (node) => node.name ?? null,\n *   refFor: (name) => `#/components/schemas/${name}`,\n * })\n * ```\n */\nexport function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupePlanOptions): DedupePlan {\n  const { isCandidate, nameFor, refFor, minOccurrences = 2 } = options\n\n  const topLevelNodes = new Set<SchemaNode>()\n\n  type Group = {\n    count: number\n    representative: SchemaNode\n    topLevelNames: Array<string>\n  }\n  const groups = new Map<string, Group>()\n\n  function record(schemaNode: SchemaNode): void {\n    const signature = signatureOf(schemaNode)\n    if (!isCandidate(schemaNode)) return\n\n    const isTopLevel = topLevelNodes.has(schemaNode) && !!schemaNode.name\n    const group = groups.get(signature)\n    if (group) {\n      group.count++\n      if (isTopLevel) group.topLevelNames.push(schemaNode.name!)\n    } else {\n      groups.set(signature, { count: 1, representative: schemaNode, topLevelNames: isTopLevel ? [schemaNode.name!] : [] })\n    }\n  }\n\n  for (const root of roots) {\n    if (root.kind === 'Schema') topLevelNodes.add(root)\n    for (const schemaNode of collectLazy<SchemaNode>(root, { schema: (node) => node })) {\n      record(schemaNode)\n    }\n  }\n\n  const canonicalBySignature = new Map<string, DedupeCanonical>()\n  const aliasNames = new Map<string, DedupeCanonical>()\n  const pendingHoists: Array<{ name: string; representative: SchemaNode }> = []\n\n  for (const [signature, group] of groups) {\n    if (group.count < minOccurrences) continue\n\n    const [firstName, ...duplicateNames] = group.topLevelNames\n    if (firstName) {\n      const canonical: DedupeCanonical = { name: firstName, ref: refFor(firstName) }\n      canonicalBySignature.set(signature, canonical)\n      for (const duplicate of duplicateNames) {\n        aliasNames.set(duplicate, canonical)\n      }\n      continue\n    }\n\n    const name = nameFor(group.representative, signature)\n    if (!name) continue\n\n    canonicalBySignature.set(signature, { name, ref: refFor(name) })\n    pendingHoists.push({ name, representative: group.representative })\n  }\n\n  // Build hoisted definitions only after every canonical name is known, so nested\n  // duplicates inside a definition also resolve to refs.\n  const hoisted = pendingHoists.map(({ name, representative }) =>\n    cleanDefinition(applyDedupe(representative, { canonicalBySignature, aliasNames }, true), name),\n  )\n\n  return { canonicalBySignature, aliasNames, hoisted }\n}\n","/**\n * The spec-specific questions a schema parser answers while turning a source document into Kubb\n * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where\n * OpenAPI, AsyncAPI, and plain JSON Schema differ.\n */\nexport type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {\n  /**\n   * Identifies the dialect in logs and diagnostics.\n   */\n  name: string\n  /**\n   * Whether the schema is nullable.\n   */\n  isNullable: (schema?: TSchema) => boolean\n  /**\n   * Whether the value is a `$ref` pointer.\n   */\n  isReference: (value?: unknown) => value is TRef\n  /**\n   * Whether the schema carries a discriminator for polymorphism.\n   */\n  isDiscriminator: (value?: unknown) => value is TDiscriminated\n  /**\n   * Whether the schema is binary data, converted to a `blob` node.\n   */\n  isBinary: (schema: TSchema) => boolean\n  /**\n   * Resolves a local `$ref` against the document, or nullish when it cannot.\n   */\n  resolveRef: <TResolved>(document: TDocument, ref: string) => TResolved | null | undefined\n}\n\n/**\n * Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the\n * dialect's type for inference.\n *\n * @example\n * ```ts\n * export const oasDialect = defineSchemaDialect({\n *   name: 'oas',\n *   isNullable,\n *   isReference,\n *   isDiscriminator,\n *   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',\n *   resolveRef,\n * })\n * ```\n */\nexport function defineSchemaDialect<TSchema, TRef, TDiscriminated, TDocument>(\n  dialect: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>,\n): SchemaDialect<TSchema, TRef, TDiscriminated, TDocument> {\n  return dialect\n}\n","import type { SchemaNode, SchemaNodeByType, SchemaType } from './nodes/index.ts'\n\n/**\n * Runtime context passed as `this` to printer handlers.\n *\n * `this.transform` dispatches to node-level handlers from `nodes`.\n *\n * @example\n * ```ts\n * const context: PrinterHandlerContext<string, {}> = {\n *   options: {},\n *   transform: () => 'value',\n * }\n * ```\n */\ntype PrinterHandlerContext<TOutput, TOptions extends object> = {\n  /**\n   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.\n   * Use `this.transform` inside `nodes` handlers and inside the `print` override.\n   */\n  transform: (node: SchemaNode) => TOutput | null\n  /**\n   * Options for this printer instance.\n   */\n  options: TOptions\n}\n\n/**\n * Handler for one schema node type.\n *\n * Use a regular function (not an arrow function) if you need `this`.\n *\n * @example\n * ```ts\n * const handler: PrinterHandler<string, {}, 'string'> = function () {\n *   return 'string'\n * }\n * ```\n */\ntype PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (\n  this: PrinterHandlerContext<TOutput, TOptions>,\n  node: SchemaNodeByType[T],\n) => TOutput | null\n\n/**\n * Partial map of per-node-type handler overrides for a printer.\n *\n * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).\n * Supply only the handlers you want to replace. The printer's built-in\n * defaults fill in the rest.\n *\n * @example\n * ```ts\n * pluginZod({\n *   printer: {\n *     nodes: {\n *       date(): string {\n *         return 'z.string().date()'\n *       },\n *     } satisfies PrinterPartial<string, PrinterZodOptions>,\n *   },\n * })\n * ```\n */\nexport type PrinterPartial<TOutput, TOptions extends object> = Partial<{\n  [K in SchemaType]: PrinterHandler<TOutput, TOptions, K>\n}>\n\n/**\n * Generic shape used by `definePrinter`.\n *\n * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)\n * - `TOptions` options passed to and stored on the printer instance\n * - `TOutput` the type emitted by node handlers\n * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)\n *\n * @example\n * ```ts\n * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>\n * ```\n */\nexport type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {\n  name: TName\n  options: TOptions\n  output: TOutput\n  printOutput: TPrintOutput\n}\n\n/**\n * Printer instance returned by a printer factory.\n *\n * @example\n * ```ts\n * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})\n * ```\n */\nexport type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {\n  /**\n   * Unique identifier supplied at creation time.\n   */\n  name: T['name']\n  /**\n   * Options for this printer instance.\n   */\n  options: T['options']\n  /**\n   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.\n   * Always dispatches through the `nodes` map. Never calls the `print` override.\n   * Reach for it when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.\n   */\n  transform: (node: SchemaNode) => T['output'] | null\n  /**\n   * Public printer. If the builder provides a root-level `print`, this calls that\n   * higher-level function (which may produce full declarations).\n   * Otherwise, falls back to the node-level dispatcher.\n   */\n  print: (node: SchemaNode) => T['printOutput'] | null\n}\n\n/**\n * Builder function passed to `definePrinter`.\n *\n * It receives resolved options and returns:\n * - `name`\n * - `options`\n * - `nodes` handlers\n * - optional top-level `print` override\n *\n * @example\n * ```ts\n * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })\n * ```\n */\ntype PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {\n  name: T['name']\n  /**\n   * Options to store on the printer.\n   */\n  options: T['options']\n  nodes: Partial<{\n    [K in SchemaType]: PrinterHandler<T['output'], T['options'], K>\n  }>\n  /**\n   * Optional root-level print override. When provided, becomes the public `printer.print`.\n   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),\n   * not the override itself, so recursion is safe.\n   */\n  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null\n}\n/**\n * Defines a schema printer: a function that takes a `SchemaNode` and emits\n * code in your target language. Each plugin that produces code from schemas\n * (TypeScript types, Zod schemas, Faker factories) ships a printer built\n * with this helper.\n *\n * The builder receives resolved options and returns:\n *\n * - `name` unique identifier for the printer.\n * - `options` stored on the returned printer instance.\n * - `nodes` map of `SchemaType` → handler. Handlers return the rendered\n *   output (a string, a TypeScript AST node, ...) for that schema type.\n * - `print` (optional), top-level override exposed as `printer.print`.\n *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.\n *\n * Without a `print` override, `printer.print` falls back to `printer.transform`\n * (the node-level dispatcher).\n *\n * @example Tiny Zod printer\n * ```ts\n * import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'\n *\n * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>\n *\n * export const zodPrinter = definePrinter<PrinterZod>((options) => ({\n *   name: 'zod',\n *   options: { strict: options.strict ?? true },\n *   nodes: {\n *     string: () => 'z.string()',\n *     object(node) {\n *       const props = node.properties\n *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)\n *         .join(', ')\n *       return `z.object({ ${props} })`\n *     },\n *   },\n * }))\n * ```\n */\nexport function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T> {\n  return createPrinterFactory<SchemaNode, SchemaType, SchemaNodeByType>((node) => node.type)(build) as (options?: T['options']) => Printer<T>\n}\n\n/**\n * Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.\n *\n * @example\n * ```ts\n * export const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionParamKind, Partial<Record<FunctionParamKind, FunctionParamNode>>>(\n *   (node) => node.kind,\n * )\n * ```\n */\nexport function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | null) {\n  return function <T extends PrinterFactoryOptions>(\n    build: (options: T['options']) => {\n      name: T['name']\n      options: T['options']\n      nodes: Partial<{\n        [K in TKey]: (\n          this: {\n            transform: (node: TNode) => T['output'] | null\n            options: T['options']\n          },\n          node: TNodeByKey[K],\n        ) => T['output'] | null\n      }>\n      print?: (\n        this: {\n          transform: (node: TNode) => T['output'] | null\n          options: T['options']\n        },\n        node: TNode,\n      ) => T['printOutput'] | null\n    },\n  ): (options?: T['options']) => {\n    name: T['name']\n    options: T['options']\n    transform: (node: TNode) => T['output'] | null\n    print: (node: TNode) => T['printOutput'] | null\n  } {\n    return (options) => {\n      const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? ({} as T['options']))\n\n      const context = {\n        options: resolvedOptions,\n        transform: (node: TNode): T['output'] | null => {\n          const key = getKey(node)\n          if (key === null) return null\n\n          const handler = nodes[key]\n\n          if (!handler) return null\n\n          return (handler as (this: typeof context, node: TNode) => T['output'] | null).call(context, node)\n        },\n      }\n\n      return {\n        name,\n        options: resolvedOptions,\n        transform: context.transform,\n        print: (printOverride ? printOverride.bind(context) : context.transform) as (node: TNode) => T['printOutput'] | null,\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -33,7 +33,7 @@ declare function isHttpOperationNode(node: OperationNode): node is HttpOperation
  * Every node definition. Adding a node means adding its `defineNode` to one
  * `nodes/*.ts` file and listing it here. The visitor tables in `visitor.ts` derive from it.
  */
-declare const nodeDefs: (NodeDef<ConstNode, Omit<ConstNode, "kind">> | NodeDef<TypeNode, Omit<TypeNode, "kind">> | NodeDef<FunctionNode, Omit<FunctionNode, "kind">> | NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNode, "kind">> | NodeDef<TextNode, string> | NodeDef<BreakNode, void> | NodeDef<JsxNode, string> | NodeDef<SchemaNode, (Omit<ObjectSchemaNode, "kind" | "properties" | "primitive"> & {
+declare const nodeDefs: (NodeDef<SchemaNode, (Omit<ObjectSchemaNode, "kind" | "properties" | "primitive"> & {
   properties?: Array<PropertyNode>;
   primitive?: "object";
 }) | DistributiveOmit<ArraySchemaNode | UnionSchemaNode | IntersectionSchemaNode | EnumSchemaNode | RefSchemaNode | DatetimeSchemaNode | DateSchemaNode | TimeSchemaNode | StringSchemaNode | NumberSchemaNode | UrlSchemaNode | (BaseNode & {
@@ -89,7 +89,7 @@ declare const nodeDefs: (NodeDef<ConstNode, Omit<ConstNode, "kind">> | NodeDef<T
   format?: string;
 } & {
   type: "ipv6";
-}) | ScalarSchemaNode, "kind">> | NodeDef<TypeLiteralNode, Pick<TypeLiteralNode, "members">> | NodeDef<IndexedAccessTypeNode, Omit<IndexedAccessTypeNode, "kind">> | NodeDef<ObjectBindingPatternNode, Pick<ObjectBindingPatternNode, "elements">> | NodeDef<FunctionParameterNode, {
+}) | ScalarSchemaNode, "kind">> | NodeDef<ConstNode, Omit<ConstNode, "kind">> | NodeDef<TypeNode, Omit<TypeNode, "kind">> | NodeDef<FunctionNode, Omit<FunctionNode, "kind">> | NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNode, "kind">> | NodeDef<TextNode, string> | NodeDef<BreakNode, void> | NodeDef<JsxNode, string> | NodeDef<ContentNode, UserContent> | NodeDef<ImportNode, Omit<ImportNode, "kind">> | NodeDef<ExportNode, Omit<ExportNode, "kind">> | NodeDef<SourceNode, Omit<SourceNode, "kind">> | NodeDef<FileNode<object>, Omit<FileNode<object>, "kind">> | NodeDef<TypeLiteralNode, Pick<TypeLiteralNode, "members">> | NodeDef<IndexedAccessTypeNode, Omit<IndexedAccessTypeNode, "kind">> | NodeDef<ObjectBindingPatternNode, Pick<ObjectBindingPatternNode, "elements">> | NodeDef<FunctionParameterNode, {
   name: string;
   type?: TypeExpression;
   optional?: boolean;
@@ -103,18 +103,18 @@ declare const nodeDefs: (NodeDef<ConstNode, Omit<ConstNode, "kind">> | NodeDef<T
   }>;
   optional?: boolean;
   default?: string;
-}> | NodeDef<FunctionParametersNode, Partial<Omit<FunctionParametersNode, "kind">>> | NodeDef<ContentNode, UserContent> | NodeDef<ResponseNode, Pick<ResponseNode, "statusCode"> & Partial<Omit<ResponseNode, "kind" | "statusCode" | "content">> & {
-  content?: Array<UserContent>;
-  schema?: SchemaNode;
-  mediaType?: string | null;
-  keysToOmit?: Array<string> | null;
-}> | NodeDef<InputNode<false>, Partial<Omit<InputNode<false>, "kind">>> | NodeDef<ImportNode, Omit<ImportNode, "kind">> | NodeDef<ExportNode, Omit<ExportNode, "kind">> | NodeDef<SourceNode, Omit<SourceNode, "kind">> | NodeDef<FileNode<object>, Omit<FileNode<object>, "kind">> | NodeDef<ParameterNode, Pick<ParameterNode, "name" | "schema" | "in"> & Partial<Omit<ParameterNode, "kind" | "name" | "schema" | "in">>> | NodeDef<PropertyNode, UserPropertyNode> | NodeDef<RequestBodyNode, UserRequestBody> | NodeDef<OperationNode, {
+}> | NodeDef<FunctionParametersNode, Partial<Omit<FunctionParametersNode, "kind">>> | NodeDef<InputNode<false>, Partial<Omit<InputNode<false>, "kind">>> | NodeDef<RequestBodyNode, UserRequestBody> | NodeDef<OperationNode, {
   [key: string]: unknown;
   operationId: string;
   method?: HttpOperationNode["method"];
   path?: HttpOperationNode["path"];
   requestBody?: UserRequestBody;
-}> | NodeDef<OutputNode, Partial<Omit<OutputNode, "kind">>>)[];
+}> | NodeDef<OutputNode, Partial<Omit<OutputNode, "kind">>> | NodeDef<ParameterNode, Pick<ParameterNode, "name" | "schema" | "in"> & Partial<Omit<ParameterNode, "kind" | "name" | "schema" | "in">>> | NodeDef<PropertyNode, UserPropertyNode> | NodeDef<ResponseNode, Pick<ResponseNode, "statusCode"> & Partial<Omit<ResponseNode, "kind" | "content" | "statusCode">> & {
+  content?: Array<UserContent>;
+  schema?: SchemaNode;
+  mediaType?: string | null;
+  keysToOmit?: Array<string> | null;
+}>)[];
 //#endregion
 //#region src/signature.d.ts
 /**

package/dist/index.js

@@ -1,5 +1,5 @@
 import "./chunk-CNktS9qV.js";
-import { A as isHttpOperationNode, C as simplifyUnion, D as extractRefName, L as httpMethods, R as schemaTypes, S as setEnumName, b as mergeAdjacentObjectsLazy, d as transform, f as walk, j as narrowSchema, l as collect, p as nodeDefs, u as collectLazy, x as setDiscriminatorEnum } from "./utils-SdZU0F3H.js";
+import { D as simplifyUnion, E as setEnumName, F as isHttpOperationNode, H as httpMethods, I as narrowSchema, T as setDiscriminatorEnum, U as schemaTypes, _ as nodeDefs, g as walk, h as transform, j as extractRefName, m as collectLazy, p as collect, w as mergeAdjacentObjectsLazy } from "./utils-Dj_KoXMv.js";
 import { $ as defineNode, A as contentDef, D as fileDef, E as exportDef, G as typeDef, H as functionDef, J as extractStringsFromNodes, M as arrowFunctionDef, N as breakDef, O as importDef, P as constDef, Q as schemaDef, S as typeLiteralDef, U as jsxDef, W as textDef, Z as createSchema, b as indexedAccessTypeDef, c as operationDef, et as syncOptionality, f as inputDef, i as parameterDef, k as sourceDef, n as responseDef, o as outputDef, q as propertyDef, u as requestBodyDef, v as functionParameterDef, x as objectBindingPatternDef, y as functionParametersDef } from "./response-DKxTr522.js";
 import { n as factory_exports } from "./factory-Du7nEP4B.js";
 import { hash } from "node:crypto";