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

package/src/nodes/code.ts

@@ -1,4 +1,4 @@
-import { defineNode } from '../node.ts'
+import { defineNode } from '../defineNode.ts'
 import type { BaseNode } from './base.ts'
 
 /**
@@ -164,55 +164,12 @@ export type FunctionNode = BaseNode & {
  * // export const getPet = () => ...
  * ```
  */
-export type ArrowFunctionNode = BaseNode & {
+export type ArrowFunctionNode = Omit<FunctionNode, 'kind'> & {
   kind: 'ArrowFunction'
-  /**
-   * Name of the arrow function (used as the `const` variable name).
-   */
-  name: string
-  /**
-   * Whether the function is a default export.
-   */
-  default?: boolean | null
-  /**
-   * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
-   */
-  params?: string | null
-  /**
-   * Whether the arrow function should be exported.
-   */
-  export?: boolean | null
-  /**
-   * Whether the arrow function is async. When `true`, the return type is wrapped in `Promise<>`.
-   */
-  async?: boolean | null
-  /**
-   * TypeScript generic type parameters.
-   *
-   * @example Constrained generics
-   * `['T', 'U extends string']`
-   */
-  generics?: string | Array<string> | null
-  /**
-   * Return type annotation.
-   *
-   * @example Type reference
-   * `'Pet'`
-   */
-  returnType?: string | null
-  /**
-   * JSDoc documentation metadata.
-   */
-  JSDoc?: JSDocNode | null
   /**
    * Render the arrow function body as a single-line expression.
    */
   singleLine?: boolean | null
-  /**
-   * Child nodes representing the function body (children of the `Function.Arrow` component).
-   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
-   */
-  nodes?: Array<CodeNode>
 }
 
 /**
@@ -285,6 +242,36 @@ export type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode |
  */
 export const constDef = defineNode<ConstNode>({ kind: 'Const' })
 
+/**
+ * Definition for the {@link TypeNode}.
+ */
+export const typeDef = defineNode<TypeNode>({ kind: 'Type' })
+
+/**
+ * Definition for the {@link FunctionNode}.
+ */
+export const functionDef = defineNode<FunctionNode>({ kind: 'Function' })
+
+/**
+ * Definition for the {@link ArrowFunctionNode}.
+ */
+export const arrowFunctionDef = defineNode<ArrowFunctionNode>({ kind: 'ArrowFunction' })
+
+/**
+ * Definition for the {@link TextNode}.
+ */
+export const textDef = defineNode<TextNode, string>({ kind: 'Text', build: (value) => ({ value }) })
+
+/**
+ * Definition for the {@link BreakNode}.
+ */
+export const breakDef = defineNode<BreakNode, void>({ kind: 'Break', build: () => ({}) })
+
+/**
+ * Definition for the {@link JsxNode}.
+ */
+export const jsxDef = defineNode<JsxNode, string>({ kind: 'Jsx', build: (value) => ({ value }) })
+
 /**
  * Creates a `ConstNode` representing a TypeScript `const` declaration.
  *
@@ -296,11 +283,6 @@ export const constDef = defineNode<ConstNode>({ kind: 'Const' })
  */
 export const createConst = constDef.create
 
-/**
- * Definition for the {@link TypeNode}.
- */
-export const typeDef = defineNode<TypeNode>({ kind: 'Type' })
-
 /**
  * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
  *
@@ -312,11 +294,6 @@ export const typeDef = defineNode<TypeNode>({ kind: 'Type' })
  */
 export const createType = typeDef.create
 
-/**
- * Definition for the {@link FunctionNode}.
- */
-export const functionDef = defineNode<FunctionNode>({ kind: 'Function' })
-
 /**
  * Creates a `FunctionNode` representing a TypeScript `function` declaration.
  *
@@ -328,11 +305,6 @@ export const functionDef = defineNode<FunctionNode>({ kind: 'Function' })
  */
 export const createFunction = functionDef.create
 
-/**
- * Definition for the {@link ArrowFunctionNode}.
- */
-export const arrowFunctionDef = defineNode<ArrowFunctionNode>({ kind: 'ArrowFunction' })
-
 /**
  * Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
  *
@@ -344,11 +316,6 @@ export const arrowFunctionDef = defineNode<ArrowFunctionNode>({ kind: 'ArrowFunc
  */
 export const createArrowFunction = arrowFunctionDef.create
 
-/**
- * Definition for the {@link TextNode}.
- */
-export const textDef = defineNode<TextNode, string>({ kind: 'Text', build: (value) => ({ value }) })
-
 /**
  * Creates a {@link TextNode} representing a raw string fragment in the source output.
  *
@@ -360,11 +327,6 @@ export const textDef = defineNode<TextNode, string>({ kind: 'Text', build: (valu
  */
 export const createText = textDef.create
 
-/**
- * Definition for the {@link BreakNode}.
- */
-export const breakDef = defineNode<BreakNode, void>({ kind: 'Break', build: () => ({}) })
-
 /**
  * Creates a {@link BreakNode} representing a line break in the source output.
  *
@@ -378,11 +340,6 @@ export function createBreak(): BreakNode {
   return breakDef.create()
 }
 
-/**
- * Definition for the {@link JsxNode}.
- */
-export const jsxDef = defineNode<JsxNode, string>({ kind: 'Jsx', build: (value) => ({ value }) })
-
 /**
  * Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
  *

package/src/nodes/content.ts

@@ -1,4 +1,4 @@
-import { defineNode } from '../node.ts'
+import { defineNode } from '../defineNode.ts'
 import type { BaseNode } from './base.ts'
 import type { SchemaNode } from './schema.ts'
 
@@ -37,15 +37,10 @@ export type ContentNode = BaseNode & {
   keysToOmit?: Array<string> | null
 }
 
-/**
- * Loosely-typed content entry accepted by the builders, normalized into a {@link ContentNode}.
- */
-export type UserContent = Omit<ContentNode, 'kind'>
-
 /**
  * Definition for the {@link ContentNode}.
  */
-export const contentDef = defineNode<ContentNode, UserContent>({
+export const contentDef = defineNode<ContentNode>({
   kind: 'Content',
   children: ['schema'],
 })

package/src/nodes/file.ts

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

package/src/nodes/function.ts

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

package/src/nodes/index.ts

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

package/src/nodes/input.ts

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

package/src/nodes/operation.ts

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

package/src/nodes/output.ts

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

package/src/nodes/parameter.ts

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

package/src/nodes/property.ts

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