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

package/dist/{response-DS5S3IG4.cjs → response-BeG6hq2D.cjs}

@@ -33,7 +33,23 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-//#region src/node.ts
+let node_crypto = require("node:crypto");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+//#region src/defineNode.ts
+/**
+* Visitor callback names, one per traversable node kind, in traversal order.
+* Kept in sync with the keys of `Visitor` in `visitor.ts`.
+*/
+const visitorKeys = [
+	"input",
+	"output",
+	"operation",
+	"schema",
+	"property",
+	"parameter",
+	"response"
+];
 /**
 * Builds a type guard that matches nodes of the given `kind`.
 */
@@ -41,52 +57,30 @@ function isKind(kind) {
 	return (node) => node.kind === kind;
 }
 /**
-* Updates a schema's `optional` and `nullish` flags from a parent's `required`
-* value and the schema's own `nullable`. Mirrors how OpenAPI parameters and
-* object properties combine "required" and "nullable" into a single AST.
-*
-* - Non-required + non-nullable → `optional: true`.
-* - Non-required + nullable → `nullish: true`.
-* - Required → both flags cleared.
-*/
-function syncOptionality(schema, required) {
-	const nullable = schema.nullable ?? false;
-	return {
-		...schema,
-		optional: !required && !nullable ? true : void 0,
-		nullish: !required && nullable ? true : void 0
-	};
-}
-/**
 * Defines a node once and derives its `create` builder, `is` guard, and traversal
 * metadata. `create` merges `defaults`, the `build` hook (or the raw input), and the
 * `kind`, so node construction lives in one place without scattered `as` casts.
 *
-* Set `rebuild: true` when the `build` hook derives fields from children. After a
-* transform rewrites those children, the registry reruns `create` so the derived
-* fields stay correct.
-*
 * @example Simple node
 * ```ts
 * const importDef = defineNode<ImportNode>({ kind: 'Import' })
 * const createImport = importDef.create
 * ```
 *
-* @example Node with a build hook that is rerun on transform
+* @example Node with a build hook
 * ```ts
 * const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
 *   kind: 'Property',
 *   build: (props) => ({ ...props, required: props.required ?? false }),
 *   children: ['schema'],
 *   visitorKey: 'property',
-*   rebuild: true,
 * })
 * ```
 */
 function defineNode(config) {
-	const { kind, defaults, build, children, visitorKey, rebuild } = config;
-	function create(input) {
-		const base = build ? build(input) : input;
+	const { kind, defaults, build, children, visitorKey } = config;
+	function create(input, dialect) {
+		const base = build ? build(input, dialect) : input;
 		return {
 			...defaults,
 			...base,
@@ -98,8 +92,7 @@ function defineNode(config) {
 		create,
 		is: isKind(kind),
 		children,
-		visitorKey,
-		rebuild
+		visitorKey
 	};
 }
 //#endregion
@@ -197,6 +190,23 @@ function pascalCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
+//#region ../../internals/utils/src/fs.ts
+/**
+* Strips the file extension from a path or file name.
+* Only removes the last `.ext` segment when the dot is not part of a directory name.
+*
+* @example
+* trimExtName('petStore.ts')             // 'petStore'
+* trimExtName('/src/models/pet.ts')      // '/src/models/pet'
+* trimExtName('/project.v2/gen/pet.ts')  // '/project.v2/gen/pet'
+* trimExtName('noExtension')             // 'noExtension'
+*/
+function trimExtName(text) {
+	const dotIndex = text.lastIndexOf(".");
+	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
+	return text;
+}
+//#endregion
 //#region src/utils/extractStringsFromNodes.ts
 /**
 * Extracts all string content from a `CodeNode` tree recursively.
@@ -222,45 +232,44 @@ function extractStringsFromNodes(nodes) {
 	}).filter(Boolean).join("\n");
 }
 //#endregion
-//#region src/nodes/property.ts
+//#region src/nodes/code.ts
 /**
-* 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 ConstNode}.
 */
-const propertyDef = defineNode({
-	kind: "Property",
-	build: (props) => {
-		const required = props.required ?? false;
-		return {
-			...props,
-			required,
-			schema: syncOptionality(props.schema, required)
-		};
-	},
-	children: ["schema"],
-	visitorKey: "property",
-	rebuild: true
+const constDef = defineNode({ kind: "Const" });
+/**
+* Definition for the {@link TypeNode}.
+*/
+const typeDef = defineNode({ kind: "Type" });
+/**
+* Definition for the {@link FunctionNode}.
+*/
+const functionDef = defineNode({ kind: "Function" });
+/**
+* Definition for the {@link ArrowFunctionNode}.
+*/
+const arrowFunctionDef = defineNode({ kind: "ArrowFunction" });
+/**
+* Definition for the {@link TextNode}.
+*/
+const textDef = defineNode({
+	kind: "Text",
+	build: (value) => ({ value })
 });
 /**
-* Creates a `PropertyNode`.
-*
-* @example
-* ```ts
-* const property = createProperty({
-*   name: 'status',
-*   required: true,
-*   schema: createSchema({ type: 'string', nullable: true }),
-* })
-* // required=true, no optional/nullish
-* ```
+* Definition for the {@link BreakNode}.
 */
-const createProperty = propertyDef.create;
-//#endregion
-//#region src/nodes/code.ts
+const breakDef = defineNode({
+	kind: "Break",
+	build: () => ({})
+});
 /**
-* Definition for the {@link ConstNode}.
+* Definition for the {@link JsxNode}.
 */
-const constDef = defineNode({ kind: "Const" });
+const jsxDef = defineNode({
+	kind: "Jsx",
+	build: (value) => ({ value })
+});
 /**
 * Creates a `ConstNode` representing a TypeScript `const` declaration.
 *
@@ -272,10 +281,6 @@ const constDef = defineNode({ kind: "Const" });
 */
 const createConst = constDef.create;
 /**
-* Definition for the {@link TypeNode}.
-*/
-const typeDef = defineNode({ kind: "Type" });
-/**
 * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
 *
 * @example
@@ -286,10 +291,6 @@ const typeDef = defineNode({ kind: "Type" });
 */
 const createType = typeDef.create;
 /**
-* Definition for the {@link FunctionNode}.
-*/
-const functionDef = defineNode({ kind: "Function" });
-/**
 * Creates a `FunctionNode` representing a TypeScript `function` declaration.
 *
 * @example
@@ -300,10 +301,6 @@ const functionDef = defineNode({ kind: "Function" });
 */
 const createFunction = functionDef.create;
 /**
-* Definition for the {@link ArrowFunctionNode}.
-*/
-const arrowFunctionDef = defineNode({ kind: "ArrowFunction" });
-/**
 * Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
 *
 * @example
@@ -314,13 +311,6 @@ const arrowFunctionDef = defineNode({ kind: "ArrowFunction" });
 */
 const createArrowFunction = arrowFunctionDef.create;
 /**
-* Definition for the {@link TextNode}.
-*/
-const textDef = defineNode({
-	kind: "Text",
-	build: (value) => ({ value })
-});
-/**
 * Creates a {@link TextNode} representing a raw string fragment in the source output.
 *
 * @example
@@ -331,13 +321,6 @@ const textDef = defineNode({
 */
 const createText = textDef.create;
 /**
-* Definition for the {@link BreakNode}.
-*/
-const breakDef = defineNode({
-	kind: "Break",
-	build: () => ({})
-});
-/**
 * Creates a {@link BreakNode} representing a line break in the source output.
 *
 * @example
@@ -350,13 +333,6 @@ function createBreak() {
 	return breakDef.create();
 }
 /**
-* Definition for the {@link JsxNode}.
-*/
-const jsxDef = defineNode({
-	kind: "Jsx",
-	build: (value) => ({ value })
-});
-/**
 * Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
 *
 * @example
@@ -380,12 +356,171 @@ const contentDef = defineNode({
 */
 const createContent = contentDef.create;
 //#endregion
+//#region src/utils/fileMerge.ts
+function sourceKey(source) {
+	return `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
+}
+function pathTypeKey(path, isTypeOnly) {
+	return `${path}:${isTypeOnly ?? false}`;
+}
+function exportKey(path, name, isTypeOnly, asAlias) {
+	return `${path}:${name ?? ""}:${isTypeOnly ?? false}:${asAlias ?? ""}`;
+}
+function importKey(path, name, isTypeOnly) {
+	return `${path}:${name ?? ""}:${isTypeOnly ?? false}`;
+}
+/**
+* Computes a multi-level sort key for exports and imports:
+* non-array names first (wildcards/namespace aliases). Type-only before value. Alphabetical path. Unnamed before named.
+*/
+function sortKey(node) {
+	const isArray = Array.isArray(node.name) ? "1" : "0";
+	const typeOnly = node.isTypeOnly ? "0" : "1";
+	const hasName = node.name != null ? "1" : "0";
+	const name = Array.isArray(node.name) ? node.name.toSorted().join("\0") : node.name ?? "";
+	return `${isArray}:${typeOnly}:${node.path}:${hasName}:${name}`;
+}
+/**
+* Deduplicates and merges `SourceNode` objects by `name + isExportable + isTypeOnly`.
+*
+* Unnamed sources are deduplicated by object reference. Returns a deduplicated array in original order.
+*/
+function combineSources(sources) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const key = sourceKey(source);
+		if (!seen.has(key)) seen.set(key, source);
+	}
+	return [...seen.values()];
+}
+/**
+* Merges `incoming` names into `existing`, preserving order and dropping duplicates.
+*
+* Shared by `combineExports` and `combineImports` for the same-path name-merge case.
+*/
+function mergeNameArrays(existing, incoming) {
+	const merged = new Set(existing);
+	for (const name of incoming) merged.add(name);
+	return [...merged];
+}
+/**
+* Deduplicates and merges `ExportNode` objects by path and type.
+*
+* Named exports with the same path and `isTypeOnly` flag have their names merged into a single export.
+* Non-array exports are deduplicated by exact identity. Returns a sorted, deduplicated array.
+*/
+function combineExports(exports) {
+	const result = [];
+	const namedByPath = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const keyed = exports.map((node) => ({
+		node,
+		key: sortKey(node)
+	}));
+	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	for (const { node: curr } of keyed) {
+		const { name, path, isTypeOnly, asAlias } = curr;
+		if (Array.isArray(name)) {
+			if (!name.length) continue;
+			const key = pathTypeKey(path, isTypeOnly);
+			const existing = namedByPath.get(key);
+			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+			else {
+				const newItem = {
+					...curr,
+					name: [...new Set(name)]
+				};
+				result.push(newItem);
+				namedByPath.set(key, newItem);
+			}
+		} else {
+			const key = exportKey(path, name, isTypeOnly, asAlias);
+			if (!seen.has(key)) {
+				result.push(curr);
+				seen.add(key);
+			}
+		}
+	}
+	return result;
+}
+/**
+* Deduplicates and merges `ImportNode` objects, filtering out unused imports.
+*
+* Retains imports that are referenced in `source` or re-exported. Imports with the same path and
+* `isTypeOnly` flag have their names merged. Returns a sorted, deduplicated, filtered array.
+*/
+function combineImports(imports, exports, source) {
+	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
+	const isUsed = (importName) => !source || source.includes(importName) || exportedNames.has(importName);
+	const importNameMemo = /* @__PURE__ */ new Map();
+	const canonicalizeName = (n) => {
+		if (typeof n === "string") return n;
+		const key = `${n.propertyName}:${n.name ?? ""}`;
+		if (!importNameMemo.has(key)) importNameMemo.set(key, n);
+		return importNameMemo.get(key);
+	};
+	const pathsWithUsedNamedImport = /* @__PURE__ */ new Set();
+	for (const node of imports) {
+		if (!Array.isArray(node.name)) continue;
+		if (node.name.some((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName))) pathsWithUsedNamedImport.add(node.path);
+	}
+	const result = [];
+	const namedByPath = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const keyed = imports.map((node) => ({
+		node,
+		key: sortKey(node)
+	}));
+	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	for (const { node: curr } of keyed) {
+		if (curr.path === curr.root) continue;
+		const { path, isTypeOnly } = curr;
+		let { name } = curr;
+		if (Array.isArray(name)) {
+			name = [...new Set(name.map(canonicalizeName))].filter((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName));
+			if (!name.length) continue;
+			const key = pathTypeKey(path, isTypeOnly);
+			const existing = namedByPath.get(key);
+			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+			else {
+				const newItem = {
+					...curr,
+					name
+				};
+				result.push(newItem);
+				namedByPath.set(key, newItem);
+			}
+		} else {
+			if (name && !isUsed(name) && !pathsWithUsedNamedImport.has(path)) continue;
+			const key = importKey(path, name, isTypeOnly);
+			if (!seen.has(key)) {
+				result.push(curr);
+				seen.add(key);
+			}
+		}
+	}
+	return result;
+}
+//#endregion
 //#region src/nodes/file.ts
 /**
 * Definition for the {@link ImportNode}.
 */
 const importDef = defineNode({ kind: "Import" });
 /**
+* Definition for the {@link ExportNode}.
+*/
+const exportDef = defineNode({ kind: "Export" });
+/**
+* Definition for the {@link SourceNode}.
+*/
+const sourceDef = defineNode({ kind: "Source" });
+/**
+* Definition for the {@link FileNode}. The fully resolved builder lives in
+* `createFile`, so this definition only supplies the guard.
+*/
+const fileDef = defineNode({ kind: "File" });
+/**
 * Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
 *
 * @example Named import
@@ -396,10 +531,6 @@ const importDef = defineNode({ kind: "Import" });
 */
 const createImport = importDef.create;
 /**
-* Definition for the {@link ExportNode}.
-*/
-const exportDef = defineNode({ kind: "Export" });
-/**
 * Creates an `ExportNode` representing a language-agnostic export/public API declaration.
 *
 * @example Named export
@@ -410,10 +541,6 @@ const exportDef = defineNode({ kind: "Export" });
 */
 const createExport = exportDef.create;
 /**
-* Definition for the {@link SourceNode}.
-*/
-const sourceDef = defineNode({ kind: "Source" });
-/**
 * Creates a `SourceNode` representing a fragment of source code within a file.
 *
 * @example
@@ -423,10 +550,64 @@ const sourceDef = defineNode({ kind: "Source" });
 */
 const createSource = sourceDef.create;
 /**
-* Definition for the {@link FileNode}. The fully resolved builder lives in
-* `createFile`, so this definition only supplies the guard.
+* 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'
+* ```
 */
-const fileDef = defineNode({ kind: "File" });
+function createFile(input) {
+	const extname = node_path.default.extname(input.baseName) || (input.baseName.startsWith(".") ? input.baseName : "");
+	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 || void 0) : [];
+	const localNames = new Set((input.sources ?? []).map((item) => item.name).filter((name) => Boolean(name)));
+	const nameOf = (item) => typeof item === "string" ? item : item.name ?? item.propertyName;
+	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: (0, node_crypto.hash)("sha256", input.path, "hex"),
+		name: trimExtName(input.baseName),
+		extname,
+		imports: resolvedImports,
+		exports: resolvedExports,
+		sources: resolvedSources,
+		meta: input.meta ?? {}
+	};
+}
 //#endregion
 //#region src/nodes/function.ts
 /**
@@ -434,44 +615,14 @@ const fileDef = defineNode({ kind: "File" });
 */
 const typeLiteralDef = defineNode({ kind: "TypeLiteral" });
 /**
-* Creates a {@link TypeLiteralNode} representing an inline anonymous object type.
-*
-* @example
-* ```ts
-* createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
-* // { petId: string }
-* ```
-*/
-const createTypeLiteral = typeLiteralDef.create;
-/**
 * Definition for the {@link IndexedAccessTypeNode}.
 */
 const indexedAccessTypeDef = defineNode({ kind: "IndexedAccessType" });
 /**
-* Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
-*
-* @example
-* ```ts
-* createIndexedAccessType({ objectType: 'DeletePetPathParams', indexType: 'petId' })
-* // DeletePetPathParams['petId']
-* ```
-*/
-const createIndexedAccessType = indexedAccessTypeDef.create;
-/**
 * Definition for the {@link ObjectBindingPatternNode}.
 */
 const objectBindingPatternDef = defineNode({ kind: "ObjectBindingPattern" });
 /**
-* Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
-*
-* @example
-* ```ts
-* createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
-* // { id, name }
-* ```
-*/
-const createObjectBindingPattern = objectBindingPatternDef.create;
-/**
 * Definition for the {@link FunctionParameterNode}. `optional` defaults to `false`.
 * Passing `properties` builds a destructured group: an {@link ObjectBindingPatternNode} name
 * paired with a {@link TypeLiteralNode} type.
@@ -496,6 +647,43 @@ const functionParameterDef = defineNode({
 	}
 });
 /**
+* Definition for the {@link FunctionParametersNode}.
+*/
+const functionParametersDef = defineNode({
+	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 }
+* ```
+*/
+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']
+* ```
+*/
+const createIndexedAccessType = indexedAccessTypeDef.create;
+/**
+* Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
+*
+* @example
+* ```ts
+* createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+* // { id, name }
+* ```
+*/
+const createObjectBindingPattern = objectBindingPatternDef.create;
+/**
 * Creates a `FunctionParameterNode`. `optional` defaults to `false`.
 *
 * @example Optional param
@@ -512,13 +700,6 @@ const functionParameterDef = defineNode({
 */
 const createFunctionParameter = functionParameterDef.create;
 /**
-* Definition for the {@link FunctionParametersNode}.
-*/
-const functionParametersDef = defineNode({
-	kind: "FunctionParameters",
-	defaults: { params: [] }
-});
-/**
 * Creates a `FunctionParametersNode` from an ordered list of parameters.
 *
 * @example
@@ -550,8 +731,8 @@ const inputDef = defineNode({
 });
 /**
 * 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
@@ -568,6 +749,10 @@ function createInput(options = {}) {
 	const { stream, ...overrides } = options;
 	if (stream) return {
 		kind: "Input",
+		meta: {
+			circularNames: [],
+			enumNames: []
+		},
 		...overrides
 	};
 	return inputDef.create(overrides);
@@ -575,18 +760,15 @@ function createInput(options = {}) {
 //#endregion
 //#region src/nodes/requestBody.ts
 /**
-* Definition for the {@link RequestBodyNode}, normalizing each content entry into a `ContentNode`.
+* Definition for the {@link RequestBodyNode}. Content entries are built upfront with
+* {@link createContent}, mirroring how `parameters` and `responses` take prebuilt nodes.
 */
 const requestBodyDef = defineNode({
 	kind: "RequestBody",
-	build: (props) => ({
-		...props,
-		content: props.content?.map(createContent)
-	}),
 	children: ["content"]
 });
 /**
-* Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
+* Creates a `RequestBodyNode`.
 */
 const createRequestBody = requestBodyDef.create;
 //#endregion
@@ -645,22 +827,22 @@ function createOutput(overrides = {}) {
 //#endregion
 //#region src/nodes/parameter.ts
 /**
-* 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.
 */
 const parameterDef = defineNode({
 	kind: "Parameter",
-	build: (props) => {
+	build: (props, dialect) => {
 		const required = props.required ?? false;
 		return {
 			...props,
 			required,
-			schema: syncOptionality(props.schema, required)
+			schema: dialect ? dialect.schema.optionality(props.schema, required) : props.schema
 		};
 	},
 	children: ["schema"],
-	visitorKey: "parameter",
-	rebuild: true
+	visitorKey: "parameter"
 });
 /**
 * Creates a `ParameterNode`.
@@ -677,6 +859,40 @@ const parameterDef = defineNode({
 */
 const createParameter = parameterDef.create;
 //#endregion
+//#region src/nodes/property.ts
+/**
+* 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.
+*/
+const propertyDef = defineNode({
+	kind: "Property",
+	build: (props, dialect) => {
+		const required = props.required ?? false;
+		return {
+			...props,
+			required,
+			schema: dialect ? dialect.schema.optionality(props.schema, required) : props.schema
+		};
+	},
+	children: ["schema"],
+	visitorKey: "property"
+});
+/**
+* Creates a `PropertyNode`.
+*
+* @example
+* ```ts
+* const property = createProperty({
+*   name: 'status',
+*   required: true,
+*   schema: createSchema({ type: 'string', nullable: true }),
+* })
+* // required=true, no optional/nullish
+* ```
+*/
+const createProperty = propertyDef.create;
+//#endregion
 //#region src/nodes/response.ts
 /**
 * Definition for the {@link ResponseNode}. A single legacy `schema` (with optional
@@ -686,14 +902,14 @@ const responseDef = defineNode({
 	kind: "Response",
 	build: (props) => {
 		const { schema, mediaType, keysToOmit, content, ...rest } = props;
-		const entries = content ?? (schema ? [{
+		const entries = content ?? (schema ? [createContent({
 			contentType: mediaType ?? "application/json",
 			schema,
 			keysToOmit: keysToOmit ?? null
-		}] : void 0);
+		})] : void 0);
 		return {
 			...rest,
-			content: entries?.map(createContent)
+			content: entries
 		};
 	},
 	children: ["content"],
@@ -706,7 +922,7 @@ const responseDef = defineNode({
 * ```ts
 * const response = createResponse({
 *   statusCode: '200',
-*   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
+*   content: [createContent({ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) })],
 * })
 * ```
 */
@@ -724,12 +940,6 @@ Object.defineProperty(exports, "__name", {
 		return __name;
 	}
 });
-Object.defineProperty(exports, "__toESM", {
-	enumerable: true,
-	get: function() {
-		return __toESM;
-	}
-});
 Object.defineProperty(exports, "arrowFunctionDef", {
 	enumerable: true,
 	get: function() {
@@ -790,6 +1000,12 @@ Object.defineProperty(exports, "createExport", {
 		return createExport;
 	}
 });
+Object.defineProperty(exports, "createFile", {
+	enumerable: true,
+	get: function() {
+		return createFile;
+	}
+});
 Object.defineProperty(exports, "createFunction", {
 	enumerable: true,
 	get: function() {
@@ -1030,12 +1246,6 @@ Object.defineProperty(exports, "sourceDef", {
 		return sourceDef;
 	}
 });
-Object.defineProperty(exports, "syncOptionality", {
-	enumerable: true,
-	get: function() {
-		return syncOptionality;
-	}
-});
 Object.defineProperty(exports, "textDef", {
 	enumerable: true,
 	get: function() {
@@ -1054,5 +1264,11 @@ Object.defineProperty(exports, "typeLiteralDef", {
 		return typeLiteralDef;
 	}
 });
+Object.defineProperty(exports, "visitorKeys", {
+	enumerable: true,
+	get: function() {
+		return visitorKeys;
+	}
+});
 
-//# sourceMappingURL=response-DS5S3IG4.cjs.map
+//# sourceMappingURL=response-BeG6hq2D.cjs.map