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

package/dist/{response-hnSw2NKE.cjs → schema-BkvrrOAr.cjs}

@@ -33,58 +33,52 @@ 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
 /**
-* Builds a type guard that matches nodes of the given `kind`.
+* Visitor callback names, one per traversable node kind, in traversal order.
+* Kept in sync with the keys of `Visitor` in `visitor.ts`.
 */
-function isKind(kind) {
-	return (node) => node.kind === kind;
-}
+const visitorKeys = [
+	"input",
+	"output",
+	"operation",
+	"schema",
+	"property",
+	"parameter",
+	"response"
+];
 /**
-* 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.
+* Builds a type guard that matches nodes of the given `kind`.
 */
-function syncOptionality(schema, required) {
-	const nullable = schema.nullable ?? false;
-	return {
-		...schema,
-		optional: !required && !nullable ? true : void 0,
-		nullish: !required && nullable ? true : void 0
-	};
+function isKind(kind) {
+	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 {
@@ -98,110 +92,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.
 *
@@ -213,10 +145,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
@@ -227,10 +155,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
@@ -241,10 +165,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
@@ -255,13 +175,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
@@ -272,13 +185,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
@@ -291,13 +197,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
@@ -321,12 +220,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
@@ -337,10 +476,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
@@ -351,10 +486,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
@@ -364,10 +495,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
 /**
@@ -375,44 +560,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.
@@ -437,6 +592,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
@@ -453,13 +645,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
@@ -491,8 +676,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
@@ -509,6 +694,10 @@ function createInput(options = {}) {
 	const { stream, ...overrides } = options;
 	if (stream) return {
 		kind: "Input",
+		meta: {
+			circularNames: [],
+			enumNames: []
+		},
 		...overrides
 	};
 	return inputDef.create(overrides);
@@ -516,18 +705,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
@@ -584,10 +770,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",
@@ -596,12 +796,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`.
@@ -620,8 +819,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",
@@ -630,12 +829,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`.
@@ -661,14 +859,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"],
@@ -681,12 +879,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
+//#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
 Object.defineProperty(exports, "__exportAll", {
 	enumerable: true,
 	get: function() {
@@ -699,12 +952,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() {
@@ -765,6 +1012,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() {
@@ -891,6 +1144,12 @@ Object.defineProperty(exports, "exportDef", {
 		return exportDef;
 	}
 });
+Object.defineProperty(exports, "extractStringsFromNodes", {
+	enumerable: true,
+	get: function() {
+		return extractStringsFromNodes;
+	}
+});
 Object.defineProperty(exports, "fileDef", {
 	enumerable: true,
 	get: function() {
@@ -951,6 +1210,12 @@ Object.defineProperty(exports, "operationDef", {
 		return operationDef;
 	}
 });
+Object.defineProperty(exports, "optionality", {
+	enumerable: true,
+	get: function() {
+		return optionality;
+	}
+});
 Object.defineProperty(exports, "outputDef", {
 	enumerable: true,
 	get: function() {
@@ -999,12 +1264,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() {
@@ -1023,5 +1282,11 @@ Object.defineProperty(exports, "typeLiteralDef", {
 		return typeLiteralDef;
 	}
 });
+Object.defineProperty(exports, "visitorKeys", {
+	enumerable: true,
+	get: function() {
+		return visitorKeys;
+	}
+});
 
-//# sourceMappingURL=response-hnSw2NKE.cjs.map
+//# sourceMappingURL=schema-BkvrrOAr.cjs.map