@kubb/ast 5.0.0-beta.61 → 5.0.0-beta.63

package/dist/{response-KUdWiDWw.js → schema-Cbnxmz4b.js}

@@ -1,56 +1,49 @@
 import "./chunk-CNktS9qV.js";
-//#region src/node.ts
+import { hash } from "node:crypto";
+import path from "node:path";
+//#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`.
 */
 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
-	};
+	return (node) => node?.kind === kind;
 }
 /**
 * 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;
+	const { kind, defaults, build, children, visitorKey } = config;
 	function create(input) {
 		const base = build ? build(input) : input;
 		return {
@@ -64,110 +57,48 @@ function defineNode(config) {
 		create,
 		is: isKind(kind),
 		children,
-		visitorKey,
-		rebuild
+		visitorKey
 	};
 }
 //#endregion
-//#region src/nodes/schema.ts
+//#region src/nodes/code.ts
 /**
-* Maps schema `type` to its underlying `primitive`.
-* Primitive types map to themselves. Special string formats map to `'string'`.
-* Complex types (`ref`, `enum`, `union`, `intersection`, `tuple`, `blob`) are left unset.
+* Definition for the {@link ConstNode}.
 */
-const TYPE_TO_PRIMITIVE = {
-	string: "string",
-	number: "number",
-	integer: "integer",
-	bigint: "bigint",
-	boolean: "boolean",
-	null: "null",
-	any: "any",
-	unknown: "unknown",
-	void: "void",
-	never: "never",
-	object: "object",
-	array: "array",
-	date: "date",
-	uuid: "string",
-	email: "string",
-	url: "string",
-	datetime: "string",
-	time: "string"
-};
+const constDef = defineNode({ kind: "Const" });
 /**
-* Definition for the {@link SchemaNode}. Object schemas default `properties` to an
-* empty array, and `primitive` is inferred from `type` when not explicitly provided.
+* Definition for the {@link TypeNode}.
 */
-const schemaDef = defineNode({
-	kind: "Schema",
-	build: (props) => {
-		if (props.type === "object") return {
-			properties: [],
-			primitive: "object",
-			...props
-		};
-		return {
-			primitive: TYPE_TO_PRIMITIVE[props.type],
-			...props
-		};
-	},
-	children: [
-		"properties",
-		"items",
-		"members",
-		"additionalProperties"
-	],
-	visitorKey: "schema"
-});
-function createSchema(props) {
-	return schemaDef.create(props);
-}
-//#endregion
-//#region ../../internals/utils/src/casing.ts
+const typeDef = defineNode({ kind: "Type" });
 /**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+* Definition for the {@link FunctionNode}.
 */
-function toCamelOrPascal(text, pascal) {
-	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-		if (word.length > 1 && word === word.toUpperCase()) return word;
-		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
+const functionDef = defineNode({ kind: "Function" });
 /**
-* Converts `text` to camelCase.
-*
-* @example Word boundaries
-* `camelCase('hello-world') // 'helloWorld'`
-*
-* @example With a prefix
-* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+* Definition for the {@link ArrowFunctionNode}.
 */
-function camelCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
-}
+const arrowFunctionDef = defineNode({ kind: "ArrowFunction" });
 /**
-* Converts `text` to PascalCase.
-*
-* @example Word boundaries
-* `pascalCase('hello-world') // 'HelloWorld'`
-*
-* @example With a suffix
-* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
+* Definition for the {@link TextNode}.
 */
-function pascalCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
-}
-//#endregion
-//#region src/nodes/code.ts
+const textDef = defineNode({
+	kind: "Text",
+	build: (value) => ({ value })
+});
 /**
-* Definition for the {@link ConstNode}.
+* Definition for the {@link BreakNode}.
 */
-const constDef = defineNode({ kind: "Const" });
+const breakDef = defineNode({
+	kind: "Break",
+	build: () => ({})
+});
+/**
+* Definition for the {@link JsxNode}.
+*/
+const jsxDef = defineNode({
+	kind: "Jsx",
+	build: (value) => ({ value })
+});
 /**
 * Creates a `ConstNode` representing a TypeScript `const` declaration.
 *
@@ -179,10 +110,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
@@ -193,10 +120,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
@@ -207,10 +130,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
@@ -221,13 +140,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
@@ -238,13 +150,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
@@ -257,13 +162,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
@@ -287,12 +185,252 @@ const contentDef = defineNode({
 */
 const createContent = contentDef.create;
 //#endregion
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+*/
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+/**
+* Converts `text` to PascalCase.
+*
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
+*
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
+*/
+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.
+*
+* Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
+* and nested node content. Used to build the full source string for import filtering.
+*/
+function extractStringsFromNodes(nodes) {
+	if (!nodes?.length) return "";
+	return nodes.map((node) => {
+		if (typeof node === "string") return node;
+		if (node.kind === "Text") return node.value;
+		if (node.kind === "Break") return "";
+		if (node.kind === "Jsx") return node.value;
+		const parts = [];
+		if ("params" in node && node.params) parts.push(node.params);
+		if ("generics" in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(", ") : node.generics);
+		if ("returnType" in node && node.returnType) parts.push(node.returnType);
+		if ("type" in node && typeof node.type === "string") parts.push(node.type);
+		const nested = extractStringsFromNodes(node.nodes);
+		if (nested) parts.push(nested);
+		return parts.join("\n");
+	}).filter(Boolean).join("\n");
+}
+//#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 `SourceNode` objects by `name + isExportable + isTypeOnly`, keeping the first of each
+* key. Unnamed sources fall back to their extracted node strings as the name part of the key. Returns
+* the 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
@@ -303,10 +441,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
@@ -317,10 +451,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
@@ -330,10 +460,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 = path.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: 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
 /**
@@ -341,44 +525,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.
@@ -403,6 +557,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
@@ -419,13 +610,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
@@ -457,8 +641,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
@@ -475,6 +659,10 @@ function createInput(options = {}) {
 	const { stream, ...overrides } = options;
 	if (stream) return {
 		kind: "Input",
+		meta: {
+			circularNames: [],
+			enumNames: []
+		},
 		...overrides
 	};
 	return inputDef.create(overrides);
@@ -482,18 +670,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
@@ -550,10 +735,24 @@ function createOutput(overrides = {}) {
 	return outputDef.create(overrides);
 }
 //#endregion
+//#region src/optionality.ts
+/**
+* Generic JSON Schema optionality: a non-required field is optional, and a
+* non-required nullable field is nullish.
+*/
+function optionality(schema, required) {
+	const nullable = schema.nullable ?? false;
+	return {
+		...schema,
+		optional: !required && !nullable ? true : void 0,
+		nullish: !required && nullable ? true : void 0
+	};
+}
+//#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`, and the schema's
+* `optional`/`nullish` flags are derived from it through {@link optionality}.
 */
 const parameterDef = defineNode({
 	kind: "Parameter",
@@ -562,12 +761,11 @@ const parameterDef = defineNode({
 		return {
 			...props,
 			required,
-			schema: syncOptionality(props.schema, required)
+			schema: optionality(props.schema, required)
 		};
 	},
 	children: ["schema"],
-	visitorKey: "parameter",
-	rebuild: true
+	visitorKey: "parameter"
 });
 /**
 * Creates a `ParameterNode`.
@@ -586,8 +784,8 @@ const createParameter = parameterDef.create;
 //#endregion
 //#region src/nodes/property.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 PropertyNode}. `required` defaults to `false`, and the schema's
+* `optional`/`nullish` flags are derived from it through {@link optionality}.
 */
 const propertyDef = defineNode({
 	kind: "Property",
@@ -596,12 +794,11 @@ const propertyDef = defineNode({
 		return {
 			...props,
 			required,
-			schema: syncOptionality(props.schema, required)
+			schema: optionality(props.schema, required)
 		};
 	},
 	children: ["schema"],
-	visitorKey: "property",
-	rebuild: true
+	visitorKey: "property"
 });
 /**
 * Creates a `PropertyNode`.
@@ -627,14 +824,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"],
@@ -647,12 +844,67 @@ 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: [] }) })],
 * })
 * ```
 */
 const createResponse = responseDef.create;
 //#endregion
-export { syncOptionality as $, importDef as A, createFunction as B, objectBindingPatternDef as C, createSource as D, createImport as E, breakDef as F, jsxDef as G, createText as H, constDef as I, camelCase as J, textDef as K, createArrowFunction as L, contentDef as M, createContent as N, exportDef as O, arrowFunctionDef as P, defineNode as Q, createBreak as R, indexedAccessTypeDef as S, createExport as T, createType as U, createJsx as V, functionDef as W, createSchema as X, pascalCase as Y, schemaDef as Z, createIndexedAccessType as _, createParameter as a, functionParameterDef as b, outputDef as c, createRequestBody as d, requestBodyDef as f, createFunctionParameters as g, createFunctionParameter as h, propertyDef as i, sourceDef as j, fileDef as k, createOperation as l, inputDef as m, responseDef as n, parameterDef as o, createInput as p, typeDef as q, createProperty as r, createOutput as s, createResponse as t, operationDef as u, createObjectBindingPattern as v, typeLiteralDef as w, functionParametersDef as x, createTypeLiteral as y, createConst as z };
+//#region src/nodes/schema.ts
+/**
+* Maps schema `type` to its underlying `primitive`.
+* Primitive types map to themselves and special string formats map to `'string'`.
+* Any type not listed here (such as `ref`, `enum`, `union`, `intersection`, `tuple`, `ipv4`, `ipv6`, `blob`) has no `primitive`.
+*/
+const TYPE_TO_PRIMITIVE = {
+	string: "string",
+	number: "number",
+	integer: "integer",
+	bigint: "bigint",
+	boolean: "boolean",
+	null: "null",
+	any: "any",
+	unknown: "unknown",
+	void: "void",
+	never: "never",
+	object: "object",
+	array: "array",
+	date: "date",
+	uuid: "string",
+	email: "string",
+	url: "string",
+	datetime: "string",
+	time: "string"
+};
+/**
+* Definition for the {@link SchemaNode}. Object schemas default `properties` to an
+* empty array, and `primitive` is inferred from `type` when not explicitly provided.
+*/
+const schemaDef = defineNode({
+	kind: "Schema",
+	build: (props) => {
+		if (props.type === "object") return {
+			properties: [],
+			primitive: "object",
+			...props
+		};
+		return {
+			primitive: TYPE_TO_PRIMITIVE[props.type],
+			...props
+		};
+	},
+	children: [
+		"properties",
+		"items",
+		"members",
+		"additionalProperties"
+	],
+	visitorKey: "schema"
+});
+function createSchema(props) {
+	return schemaDef.create(props);
+}
+//#endregion
+export { textDef as $, createImport as A, createContent as B, functionParameterDef as C, typeLiteralDef as D, objectBindingPatternDef as E, sourceDef as F, createBreak as G, breakDef as H, extractStringsFromNodes as I, createJsx as J, createConst as K, camelCase as L, exportDef as M, fileDef as N, createExport as O, importDef as P, jsxDef as Q, pascalCase as R, createTypeLiteral as S, indexedAccessTypeDef as T, constDef as U, arrowFunctionDef as V, createArrowFunction as W, createType as X, createText as Y, functionDef as Z, inputDef as _, createProperty as a, createIndexedAccessType as b, parameterDef as c, outputDef as d, typeDef as et, createOperation as f, createInput as g, requestBodyDef as h, responseDef as i, createSource as j, createFile as k, optionality as l, createRequestBody as m, schemaDef as n, visitorKeys as nt, propertyDef as o, operationDef as p, createFunction as q, createResponse as r, createParameter as s, createSchema as t, defineNode as tt, createOutput as u, createFunctionParameter as v, functionParametersDef as w, createObjectBindingPattern as x, createFunctionParameters as y, contentDef as z };
 
-//# sourceMappingURL=response-KUdWiDWw.js.map
+//# sourceMappingURL=schema-Cbnxmz4b.js.map