@kubb/ast 5.18.5 → 5.18.6

package/dist/index.cjs

@@ -2,6 +2,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 // \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
@@ -29,14 +33,29 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
-let node_crypto = require("node:crypto");
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
+let node_crypto = require("node:crypto");
+// ../../internals/utils/src/promise.ts
+/**
+* Returns the value cached under `key` in `store`, computing and storing it on the first call.
+* Pass a `WeakMap` for object keys, so an entry goes away with its key, or a `Map` for primitive
+* keys. A cached `null` or `undefined` counts as a hit, so `compute` runs once per key.
+*
+* @example
+* `const refs = memo(refCache, node, () => collectRefs(node))`
+*/
+function memo(store, key, compute) {
+	if (store.has(key)) return store.get(key);
+	const value = compute();
+	store.set(key, value);
+	return value;
+}
 // src/constants.ts
 /**
 * Node kind discriminators used by every AST node (for example `node.kind === nodeKinds.text`).
 */
-const nodeKinds = {
+const nodeKinds$1 = {
 	input: "Input",
 	operation: "Operation",
 	schema: "Schema",
@@ -62,7 +81,7 @@ const nodeKinds = {
 *
 * Each value is a stable discriminator across the AST (for example `schema.type === schemaTypes.object`).
 */
-const schemaTypes = {
+const schemaTypes$1 = {
 	/**
 	* Text value.
 	*/
@@ -170,6 +189,19 @@ const schemaTypes = {
 	*/
 	never: "never"
 };
+// src/optionality.ts
+/**
+* Generic JSON Schema optionality: a non-required field is optional, and a
+* non-required nullable field is nullish.
+*/
+function applyOptionality(schema, required) {
+	const nullable = schema.nullable ?? false;
+	return {
+		...schema,
+		optional: !required && !nullable ? true : void 0,
+		nullish: !required && nullable ? true : void 0
+	};
+}
 // src/guards.ts
 /**
 * Narrows a `SchemaNode` to the variant that matches `type`.
@@ -180,22 +212,204 @@ const schemaTypes = {
 * const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
 * ```
 */
-function narrowSchema(node, type) {
+function narrowSchema$1(node, type) {
 	return node?.type === type ? node : null;
 }
+__name(narrowSchema$1, "narrowSchema");
 /**
 * Narrows an `OperationNode` to an `HttpOperationNode` so `method` and `path` are present.
 *
 * @example
 * ```ts
-* if (isHttpOperationNode(node)) {
+* if (ast.http.isOperation(node)) {
 *   console.log(node.method, node.path)
 * }
 * ```
 */
-function isHttpOperationNode(node) {
+function isHttpOperationNode$1(node) {
 	return node.protocol === "http" || node.method !== void 0 && node.path !== void 0;
 }
+__name(isHttpOperationNode$1, "isHttpOperationNode");
+// src/mediaType/index.ts
+var mediaType_exports = /* @__PURE__ */ __exportAll({
+	getBase: () => getBase,
+	isJson: () => isJson,
+	isStream: () => isStream
+});
+const jsonMediaTypes = /* @__PURE__ */ new Set(["application/json", "text/json"]);
+const streamMediaTypes = /* @__PURE__ */ new Set([
+	"application/jsonl",
+	"application/x-ndjson",
+	"application/json-seq",
+	"text/event-stream"
+]);
+/** The media type without its parameters, in lower case: `Text/Plain; charset=utf-8` gives `text/plain`. */
+function getBase(mediaType) {
+	return (typeof mediaType === "string" ? mediaType : mediaType.contentType).split(";")[0].trim().toLowerCase();
+}
+/** Whether the media type is `application/json`, `text/json`, or has a `+json` suffix. */
+function isJson(mediaType) {
+	const baseType = getBase(mediaType);
+	return jsonMediaTypes.has(baseType) || baseType.endsWith("+json");
+}
+/** Whether the media type is a stream of items: SSE, JSON Lines, or a `+json-seq` sequence. */
+function isStream(mediaType) {
+	const baseType = getBase(mediaType);
+	return streamMediaTypes.has(baseType) || baseType.startsWith("application/") && baseType.endsWith("+json-seq");
+}
+// src/utils/schemaProperties.ts
+/**
+* Finds every matching property exposed by an object, resolved reference, or intersection.
+*
+* References are followed through their parsed `schema`. Circular references terminate without
+* revisiting a node. Unions are not traversed because a property on one branch does not describe
+* every branch.
+*
+* @example Faker discriminator narrowing
+* ```ts
+* const values = resolveSchemaProperties({ node: member, propertyName: union.discriminatorPropertyName }).flatMap(({ schema }) =>
+*   getSchemaLiteralValues(schema),
+* )
+* const typeName = `Extract<Pet, { type: ${values.map(JSON.stringify).join(' | ')} }>`
+* ```
+*
+* @example Zod discriminated unions
+* ```ts
+* const canDiscriminate = union.members?.every(
+*   (member) => resolveSchemaProperties({ node: member, propertyName: 'type' }).length > 0,
+* )
+* const expression = canDiscriminate ? `z.discriminatedUnion('type', members)` : `z.union(members)`
+* ```
+*
+* @example TypeScript property lookup
+* ```ts
+* const properties = resolveSchemaProperties({ node: schema, propertyName: 'status' })
+* const statusSchemas = properties.map((property) => print(property.schema))
+* ```
+*/
+function resolveSchemaProperties$1({ node, propertyName }) {
+	const properties = [];
+	walkSchema(node, "intersection", (current) => {
+		if (current.type !== "object") return;
+		const property = current.properties.find((candidate) => candidate.name === propertyName);
+		if (property) properties.push(property);
+	});
+	return properties;
+}
+__name(resolveSchemaProperties$1, "resolveSchemaProperties");
+function walkSchema(node, through, visit) {
+	const visited = /* @__PURE__ */ new WeakSet();
+	function walk(current) {
+		if (!current || visited.has(current)) return;
+		visited.add(current);
+		visit(current);
+		if (current.type === "ref") return walk(current.schema);
+		if (current.type === through) for (const member of current.members ?? []) walk(member);
+	}
+	walk(node);
+}
+/**
+* Reads the unique literal values represented by an enum, resolved reference, or union.
+*
+* Named enum values take precedence over simple enum values, matching how renderers consume
+* `EnumSchemaNode`.
+*
+* @example
+* ```ts
+* const values = getSchemaLiteralValues(enumNode)
+* // ['cat', 'dog']
+* ```
+*/
+function getSchemaLiteralValues$1(node) {
+	const values = /* @__PURE__ */ new Set();
+	walkSchema(node, "union", (current) => {
+		if (current.type !== "enum") return;
+		for (const { value } of current.namedEnumValues ?? current.enumValues?.map((value) => ({ value })) ?? []) values.add(value);
+	});
+	return [...values];
+}
+__name(getSchemaLiteralValues$1, "getSchemaLiteralValues");
+function collectPropertyNames(node) {
+	const names = /* @__PURE__ */ new Set();
+	walkSchema(node, "intersection", (current) => {
+		if (current.type === "object") for (const property of current.properties) names.add(property.name);
+	});
+	return names;
+}
+/**
+* Infers an implicit discriminator: a property every member exposes with a distinct single
+* literal value, the same shape a declared OpenAPI `discriminator` already narrows on.
+*/
+function inferDiscriminatorPropertyName$1(members) {
+	if (members.length < 2) return void 0;
+	let candidates;
+	for (const member of members) {
+		const names = collectPropertyNames(member);
+		candidates = candidates ? new Set([...candidates].filter((name) => names.has(name))) : names;
+	}
+	for (const name of candidates ?? []) {
+		const values = members.map((member) => {
+			const literals = new Set(resolveSchemaProperties$1({
+				node: member,
+				propertyName: name
+			}).flatMap((property) => getSchemaLiteralValues$1(property.schema)));
+			return literals.size === 1 ? [...literals][0] : void 0;
+		});
+		if (values.every((value) => value !== void 0) && new Set(values).size === members.length) return name;
+	}
+}
+__name(inferDiscriminatorPropertyName$1, "inferDiscriminatorPropertyName");
+// src/schema/index.ts
+var schema_exports = /* @__PURE__ */ __exportAll({
+	applyOptionality: () => applyOptionality,
+	find: () => findSchema$1,
+	findProperties: () => resolveSchemaProperties$1,
+	getEmbeddedJson: () => getEmbeddedJson,
+	getLiterals: () => getSchemaLiteralValues$1,
+	getNumberBounds: () => getNumberBounds,
+	inferDiscriminator: () => inferDiscriminatorPropertyName$1,
+	isString: () => isString,
+	narrow: () => narrowSchema$1,
+	types: () => schemaTypes$1
+});
+const plainStringTypes = /* @__PURE__ */ new Set([
+	"string",
+	"uuid",
+	"email",
+	"url",
+	"datetime"
+]);
+/** The schema of the JSON document a string holds (`contentMediaType` with `contentSchema`), else `undefined`. */
+function getEmbeddedJson({ content }) {
+	if (!content?.schema || content.encoding || !content.mediaType) return void 0;
+	return isJson(content.mediaType) ? content.schema : void 0;
+}
+/** Whether a schema prints as a plain `string`: string-like types, and `date` or `time` with a `'string'` representation. */
+function isString(node) {
+	if (plainStringTypes.has(node.type)) return true;
+	const temporal = narrowSchema$1(node, "date") ?? narrowSchema$1(node, "time");
+	return temporal ? temporal.representation !== "date" : false;
+}
+/**
+* The tightest inclusive bounds of a number schema. An exclusive bound moves to the next point of `step` (`1` for an
+* integer), an integer bound rounds inward, and an integer bound past `Number.MAX_SAFE_INTEGER` is left out, since it
+* prints as a rounded or invalid literal.
+*/
+function getNumberBounds({ min, max, exclusive, integer = false, step }) {
+	const grid = step ?? (integer ? 1 : void 0);
+	const above = (bound) => grid ? (Math.floor(bound / grid) + 1) * grid : bound;
+	const below = (bound) => grid ? (Math.ceil(bound / grid) - 1) * grid : bound;
+	const tightest = (pick, bounds) => {
+		const usable = bounds.filter((bound) => bound !== void 0 && (!integer || Number.isSafeInteger(bound)));
+		return usable.length ? pick(...usable) : void 0;
+	};
+	const lower = tightest(Math.max, [min !== void 0 && integer ? Math.ceil(min) : min, exclusive?.min === void 0 ? void 0 : above(exclusive.min)]);
+	const upper = tightest(Math.min, [max !== void 0 && integer ? Math.floor(max) : max, exclusive?.max === void 0 ? void 0 : below(exclusive.max)]);
+	return {
+		...lower !== void 0 ? { min: lower } : {},
+		...upper !== void 0 ? { max: upper } : {}
+	};
+}
 // src/visitor.ts
 /**
 * Child node fields per node kind, in traversal order (Babel's `VISITOR_KEYS`).
@@ -273,7 +487,7 @@ function isNodeRecord(value) {
 * ```
 */
 function getChildren(node, recurse) {
-	if (node.kind === nodeKinds.schema && !recurse) return [];
+	if (node.kind === nodeKinds$1.schema && !recurse) return [];
 	const children = [];
 	visitChildNodes(node, (child) => {
 		children.push(child);
@@ -281,12 +495,18 @@ function getChildren(node, recurse) {
 	});
 	return children;
 }
+function isNeverPrinted({ node, key }) {
+	if (node.kind !== nodeKinds$1.schema) return false;
+	if (key === "contains" && (node.type === "array" || node.type === "tuple")) return node.contains?.min === 0 && node.contains.max === void 0;
+	if (key === "content" && node.type === "string") return !getEmbeddedJson(node);
+	return false;
+}
 /**
 * Calls `visit` for each direct child node and stops at the first call that returns `true`.
-* With `checks: true`, a schema's {@link schemaCheckKeys} fields are walked too.
+* With `checks: true`, a schema's {@link schemaCheckKeys} fields are walked too, except checks that cannot fail.
 */
 function visitChildNodes(node, visit, { checks = false } = {}) {
-	const keys = checks && node.kind === nodeKinds.schema ? [...VISITOR_KEYS[node.kind] ?? [], ...schemaCheckKeys] : VISITOR_KEYS[node.kind];
+	const keys = checks && node.kind === nodeKinds$1.schema ? [...VISITOR_KEYS[node.kind] ?? [], ...schemaCheckKeys] : VISITOR_KEYS[node.kind];
 	if (!keys) return false;
 	const record = node;
 	const seen = /* @__PURE__ */ new Set();
@@ -300,6 +520,10 @@ function visitChildNodes(node, visit, { checks = false } = {}) {
 		return false;
 	};
 	for (const key of keys) {
+		if (checks && isNeverPrinted({
+			node,
+			key
+		})) continue;
 		const value = record[key];
 		if (Array.isArray(value)) {
 			for (const item of value) if (isNode(item) ? visitOnce(item) : isNodeRecord(item) && visitRecord(item)) return true;
@@ -323,10 +547,10 @@ function visitChildNodes(node, visit, { checks = false } = {}) {
 * })
 * ```
 */
-function findSchema(node, { predicate, followRefs = false }) {
+function findSchema$1(node, { predicate, followRefs = false }) {
 	const seen = followRefs ? /* @__PURE__ */ new WeakSet() : void 0;
 	const walk = (current) => {
-		if (current.kind === nodeKinds.schema) {
+		if (current.kind === nodeKinds$1.schema) {
 			if (predicate(current)) return current;
 			if (seen) {
 				if (seen.has(current)) return void 0;
@@ -346,6 +570,7 @@ function findSchema(node, { predicate, followRefs = false }) {
 	};
 	return walk(node);
 }
+__name(findSchema$1, "findSchema");
 /**
 * Runs the visitor callback that matches `node.kind` with the traversal
 * context. The result is a replacement node, a collected value, or `undefined`
@@ -385,10 +610,11 @@ function applyVisitor(node, visitor, parent) {
 * })
 * ```
 */
-function transform(node, options) {
+function transform$1(node, options) {
 	const { depth, parent, ...visitor } = options;
 	return transformNode(node, visitor, (depth ?? "deep") === "deep", parent);
 }
+__name(transform$1, "transform");
 /**
 * Visits a single node, then immutably rebuilds its children. Returns the original
 * reference when neither the visitor nor the child rebuild changed anything, so callers
@@ -402,7 +628,7 @@ function transformNode(node, visitor, recurse, parent) {
 * (e.g. `additionalProperties: true`) intact.
 */
 function transformChildren(node, visitor, recurse) {
-	const keys = node.kind === nodeKinds.schema && !recurse ? void 0 : VISITOR_KEYS[node.kind];
+	const keys = node.kind === nodeKinds$1.schema && !recurse ? void 0 : VISITOR_KEYS[node.kind];
 	if (!keys) return node;
 	const record = node;
 	let updates;
@@ -449,161 +675,439 @@ function transformChildren(node, visitor, recurse) {
 	};
 }
 /**
-* Lazy depth-first collection pass. Yields every non-null value returned by
-* the visitor callbacks. Use `collectSync` for the eager array form.
-*
-* @example Collect every operationId
-* ```ts
-* const ids: string[] = []
-* for (const id of collect<string>(root, {
-*   operation(node) {
-*     return node.operationId
-*   },
-* })) {
-*   ids.push(id)
-* }
-* ```
-*/
-function* collect(node, options) {
-	const { depth, parent, ...visitor } = options;
-	yield* collectNode(node, visitor, (depth ?? "deep") === "deep", parent);
-}
-function* collectNode(node, visitor, recurse, parent) {
-	const v = applyVisitor(node, visitor, parent);
-	if (v != null) yield v;
-	for (const child of getChildren(node, recurse)) yield* collectNode(child, visitor, recurse, node);
-}
-/**
-* Eager depth-first collection pass. Gathers every non-null value the visitor
+* Depth-first collection pass. Gathers every non-null value the visitor
 * callbacks return into an array.
 *
 * @example Collect every operationId
 * ```ts
-* const ids = collectSync<string>(root, {
+* const ids = collect<string>(root, {
 *   operation(node) {
 *     return node.operationId
 *   },
 * })
 * ```
 */
-function collectSync(node, options) {
+function collect$1(node, options) {
 	const { depth, parent, ...visitor } = options;
 	const result = [];
 	collectInto(node, visitor, (depth ?? "deep") === "deep", parent, result);
 	return result;
 }
+__name(collect$1, "collect");
 function collectInto(node, visitor, recurse, parent, result) {
 	const v = applyVisitor(node, visitor, parent);
 	if (v != null) result.push(v);
 	for (const child of getChildren(node, recurse)) collectInto(child, visitor, recurse, node, result);
 }
-// src/defineMacro.ts
+// src/utils/refs.ts
 /**
-* Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain
-* list keeps its authored order.
+* Returns the last segment of a `$ref` pointer, for example `'Pet'` for `#/components/schemas/Pet`.
+* The segment is decoded like the pointer resolver does: percent-escapes first, then `~1` and `~0`
+* (RFC 6901), so `a~1b~0c` names the component `a/b~c`.
 */
-function enforceWeight(enforce) {
-	if (enforce === "pre") return 0;
-	if (enforce === "post") return 2;
-	return 1;
+function refName$1(ref) {
+	const cached = refNames.get(ref);
+	if (cached !== void 0) return cached;
+	const segment = ref.split("/").at(-1) ?? ref;
+	let decoded = segment;
+	try {
+		decoded = decodeURIComponent(segment);
+	} catch {}
+	const name = decoded.replaceAll("~1", "/").replaceAll("~0", "~");
+	if (refNames.size >= memoLimit) refNames.clear();
+	refNames.set(ref, name);
+	return name;
 }
+__name(refName$1, "refName");
+const refNames = /* @__PURE__ */ new Map();
+const memoLimit = 1e5;
 /**
-* Compares two `enforce` hints for `Array.prototype.sort`: `pre` first, unmarked next, `post`
-* last. Equal hints compare as `0`, so a stable sort keeps authored order within a bucket.
+* Resolves the emitted name of the schema a ref node points at. Prefers `targetName` (set when
+* the referenced schema was renamed, e.g. to break a collision), then the last segment of `ref`,
+* then `name`, then the nested `schema.name`.
+*
+* Returns `null` for non-ref nodes or when no name resolves.
 *
 * @example
-* `plugins.sort((a, b) => compareEnforce(a.enforce, b.enforce))`
+* `resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' }) // 'Pet'`
+*
+* @example Collision-renamed target
+* `resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Order', targetName: 'OrderSchema' }) // 'OrderSchema'`
 */
-function compareEnforce(a, b) {
-	return enforceWeight(a) - enforceWeight(b);
+function resolveRefName$1(node) {
+	if (!node || node.type !== "ref") return null;
+	if (node.targetName) return node.targetName;
+	if (node.ref) return refName$1(node.ref);
+	return node.name ?? node.schema?.name ?? null;
 }
+__name(resolveRefName$1, "resolveRefName");
 /**
-* Types a macro for inference and a single construction site, mirroring `defineExtension`.
-* Adds no runtime behavior.
+* Follows a resolved ref chain to its target schema. Returns an unresolved or cyclic ref as is.
 *
 * @example
 * ```ts
-* const macroUntagged = defineMacro({
-*   name: 'untagged',
-*   operation(node) {
-*     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }
-*   },
-* })
+* const target = resolveRef(refSchema)
 * ```
 */
-function defineMacro(macro) {
-	return macro;
+function resolveRef$1(node) {
+	if (node.type !== "ref" || !node.schema) return node;
+	const seen = /* @__PURE__ */ new WeakSet();
+	let current = node;
+	while (current.type === "ref" && current.schema) {
+		if (seen.has(current)) return current;
+		seen.add(current);
+		current = current.schema;
+	}
+	return current;
 }
+__name(resolveRef$1, "resolveRef");
+/** Fields of a ref node that describe the ref itself, so they never override the resolved schema. */
+const REF_OWN_KEYS = /* @__PURE__ */ new Set([
+	"kind",
+	"type",
+	"name",
+	"ref",
+	"schema"
+]);
 /**
-* Runs every macro's callback for one node kind in order, chaining the result so each macro sees
-* the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the
-* original reference (structural sharing).
+* Merges a ref node with its resolved schema, giving the fields set at the usage site precedence.
+*
+* Every field on the ref except `kind`, `type`, `name`, `ref`, and `schema` overrides the same field
+* of the resolved `schema` (for example `description`, `nullable`, `readOnly`, `deprecated`). Fields
+* left `undefined` on the ref do not shadow the resolved schema. A ref without a resolved `schema`
+* is returned as is.
+*
+* @example
+* ```ts
+* const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A pet', schema: petSchema })
+* mergeRefWithSchema(ref) // petSchema's fields with description 'A pet'
+* ```
 */
-function chain({ macros, key, node, context }) {
-	let current = node;
-	for (const macro of macros) {
-		const callback = macro[key];
-		if (!callback) continue;
-		if (macro.match && !macro.match(current)) continue;
-		const next = callback(current, context);
-		if (next != null) current = next;
+function mergeRefWithSchema$1(node) {
+	if (!node.schema) return node;
+	const merged = { ...node.schema };
+	for (const key of Object.keys(node)) {
+		const value = node[key];
+		if (value !== void 0 && !REF_OWN_KEYS.has(key)) merged[key] = value;
 	}
-	return current === node ? void 0 : current;
+	return merged;
 }
+__name(mergeRefWithSchema$1, "mergeRefWithSchema");
 /**
-* Folds an ordered list of macros into a single {@link Visitor} for `transform`. Macros are
-* stable-sorted by `enforce`, then applied sequentially per node so later macros see earlier output.
-*/
-function composeMacros(macros) {
-	const ordered = [...macros].sort((a, b) => compareEnforce(a.enforce, b.enforce));
-	const visitor = {};
-	for (const key of visitorKeys) {
-		if (!ordered.some((macro) => typeof macro[key] === "function")) continue;
-		const callback = (node, context) => chain({
-			macros: ordered,
-			key,
-			node,
-			context
-		});
-		visitor[key] = callback;
-	}
-	return visitor;
+* Returns `true` when a schema is a bare ref without modifiers, metadata, or omit keys.
+*
+* Modifiers inherited from the resolved schema are included in the check because a ref emits the
+* referenced schema variable with those modifiers already applied.
+*/
+function isBareRef$1(node, keysToOmit) {
+	if (!node || node.type !== "ref") return false;
+	const meta = mergeRefWithSchema$1(node);
+	return !meta.nullable && !meta.optional && !meta.nullish && meta.default === void 0 && !meta.description && !meta.examples?.length && !keysToOmit?.length;
 }
+__name(isBareRef$1, "isBareRef");
+// src/utils/schemaGraph.ts
+const refEntries = /* @__PURE__ */ new WeakMap();
+const checkRefEntries = /* @__PURE__ */ new WeakMap();
+const schemaRefs = /* @__PURE__ */ new WeakMap();
+const importedRefNames = /* @__PURE__ */ new WeakMap();
+const importedCheckRefNames = /* @__PURE__ */ new WeakMap();
 /**
-* Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s
-* structural sharing, so an empty or no-op macro list returns the same reference. Pass
-* `depth: 'shallow'` to rewrite the root node only.
+* Walks a node's subtree once and lists every ref it holds, in traversal order, as the resolved
+* name plus whether the ref carries a `$ref` pointer. Memoized per node and per `checks` mode, so
+* each helper below scans a schema once.
+*/
+function collectRefEntries(node, { checks }) {
+	return memo(checks ? checkRefEntries : refEntries, node, () => {
+		const entries = [];
+		const walk = (current) => {
+			if (current.kind === nodeKinds$1.schema && current.type === "ref") {
+				const name = resolveRefName$1(current);
+				if (name) entries.push({
+					name,
+					hasPointer: Boolean(current.ref)
+				});
+			}
+			visitChildNodes(current, walk, { checks });
+			return false;
+		};
+		walk(node);
+		return entries;
+	});
+}
+/**
+* Collects the names of every schema a node's subtree references, resolved with `ast.ref.getName`.
+* Each ref contributes its name only, so the schema it points to is never traversed. Memoized by
+* node identity, which lets `findCircularSchemas` and `ast.graph.containsCircular` share one scan per schema.
 *
 * @example
 * ```ts
-* const next = applyMacros(root, [macroIntegerToString])
+* collectSchemaRefs(petSchema)
+* // Set { 'Category', 'Tag' }
 * ```
+*/
+function collectSchemaRefs$1(node) {
+	return memo(schemaRefs, node, () => new Set(collectRefEntries(node, { checks: true }).map((entry) => entry.name)));
+}
+__name(collectSchemaRefs$1, "collectSchemaRefs");
+/**
+* Collects the de-duplicated target names of every pointer-carrying ref in a node's subtree, in
+* first-occurrence order. Memoized by node identity, so `resolver.imports` reads the same result
+* across the ts, zod, and faker plugins instead of re-scanning the same schema per plugin.
 *
-* @example Apply to the root node only
+* Only refs that carry a `$ref` pointer count, so a synthesized ref pointing at a sibling in the
+* same file (a union member created by name) is left out. That leaves exactly the set
+* `resolver.imports` emits. Refs inside `conditionals`, `contains` and `content` count only with
+* `checks: true`, for a plugin that prints those checks.
+*
+* @example
 * ```ts
-* const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })
+* collectImportedRefNames(petSchema)
+* // ['Category', 'Tag']
 * ```
 */
-function applyMacros(root, macros, options) {
-	if (macros.length === 0) return root;
-	return transform(root, {
-		...composeMacros(macros),
-		...options
-	});
+function collectImportedRefNames$1(node, { checks = false } = {}) {
+	return memo(checks ? importedCheckRefNames : importedRefNames, node, () => [...new Set(collectRefEntries(node, { checks }).flatMap((entry) => entry.hasPointer ? [entry.name] : []))]);
 }
-// src/optionality.ts
+__name(collectImportedRefNames$1, "collectImportedRefNames");
 /**
-* Generic JSON Schema optionality: a non-required field is optional, and a
-* non-required nullable field is nullish.
+* Collects the names of all top-level schemas transitively used by a set of operations.
+*
+* An operation uses a schema when its parameters, request body, or responses reference it, directly
+* or through other named schemas. Once a name is added to the result it is not revisited, so
+* reference cycles terminate.
+*
+* Pair it with `include` filters so schemas reachable only from excluded operations stay ungenerated.
+*
+* @example Only generate schemas referenced by included operations
+* ```ts
+* const includedOps = operations.filter((op) => resolver.default.options(op, { options, include }) !== null)
+* const allowed = collectUsedSchemaNames(includedOps, schemas)
+*
+* for (const schema of schemas) {
+*   if (schema.name && !allowed.has(schema.name)) continue
+*   // generate schema
+* }
+* ```
 */
-function optionality(schema, required) {
-	const nullable = schema.nullable ?? false;
+function collectUsedSchemaNames$1(operations, schemas) {
+	const schemaMap = /* @__PURE__ */ new Map();
+	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
+	const result = /* @__PURE__ */ new Set();
+	function visitSchema(schema) {
+		for (const name of collectSchemaRefs$1(schema)) if (!result.has(name)) {
+			result.add(name);
+			const namedSchema = schemaMap.get(name);
+			if (namedSchema) visitSchema(namedSchema);
+		}
+	}
+	for (const op of operations) for (const schema of collect$1(op, {
+		depth: "shallow",
+		schema: (node) => node
+	})) visitSchema(schema);
+	return result;
+}
+__name(collectUsedSchemaNames$1, "collectUsedSchemaNames");
+/**
+* Finds every schema that takes part in a circular dependency chain, including direct self-loops.
+*
+* Wrap the returned schema positions in a deferred construct (a lazy getter or `z.lazy(() => …)`) so
+* the generated code does not recurse forever. Refs are followed by name only, so the walk stays
+* linear in the size of the schema graph.
+*
+* @note Call this once on the full graph, then check individual schemas with `ast.graph.containsCircular()`.
+*/
+function findCircularSchemas$1(schemas) {
+	const graph = /* @__PURE__ */ new Map();
+	for (const schema of schemas) if (schema.name) graph.set(schema.name, collectSchemaRefs$1(schema));
+	const circular = /* @__PURE__ */ new Set();
+	for (const start of graph.keys()) {
+		const visited = /* @__PURE__ */ new Set();
+		const stack = [...graph.get(start) ?? []];
+		while (stack.length > 0) {
+			const node = stack.pop();
+			if (node === start) {
+				circular.add(start);
+				break;
+			}
+			if (visited.has(node)) continue;
+			visited.add(node);
+			const next = graph.get(node);
+			if (next) for (const r of next) stack.push(r);
+		}
+	}
+	return circular;
+}
+__name(findCircularSchemas$1, "findCircularSchemas");
+// src/graph/index.ts
+var graph_exports = /* @__PURE__ */ __exportAll({
+	containsCircular: () => containsCircular,
+	getCircularNames: () => findCircularSchemas$1,
+	getImportedNames: () => collectImportedRefNames$1,
+	getRefNames: () => collectSchemaRefs$1,
+	getUsedNames: () => collectUsedSchemaNames$1
+});
+/** Whether a schema, or anything inside it, refers to one of `circularSchemas`, other than `excludeName`. */
+function containsCircular(node, { circularSchemas, excludeName }) {
+	if (!node || circularSchemas.size === 0) return false;
+	for (const name of collectSchemaRefs$1(node)) if (name !== excludeName && circularSchemas.has(name)) return true;
+	return false;
+}
+// src/http/requestBody.ts
+var requestBody_exports = /* @__PURE__ */ __exportAll({ getSchema: () => getSchema });
+/** The schema of the first request body entry, else `undefined` when the operation takes no body. */
+function getSchema(node) {
+	return node.requestBody?.content?.[0]?.schema;
+}
+// src/http/status.ts
+var status_exports = /* @__PURE__ */ __exportAll({
+	getClass: () => statusClass,
+	isError: () => isError,
+	isSuccess: () => isSuccess,
+	toCode: () => toCode
+});
+const classByRange = /* @__PURE__ */ new Map([
+	["1xx", 1],
+	["2xx", 2],
+	["3xx", 3],
+	["4xx", 4],
+	["5xx", 5]
+]);
+/** The class digit of a status code or range: `2` for `201` and `2xx`, `null` for `default`. */
+function statusClass(input) {
+	const statusCode = typeof input === "object" ? input.statusCode : input;
+	const rangeClass = classByRange.get(String(statusCode));
+	if (rangeClass) return rangeClass;
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? null : Math.floor(code / 100);
+}
+function isSuccess(statusCode) {
+	return statusClass(statusCode) === 2;
+}
+function isError(statusCode) {
+	const code = statusClass(statusCode);
+	return code !== null && code >= 4;
+}
+/** One concrete code for a status or range: `200` for `2xx` and `default`, the code itself otherwise. */
+function toCode(input) {
+	const statusCode = typeof input === "object" ? input.statusCode : input;
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? (statusClass(statusCode) ?? 2) * 100 : code;
+}
+// src/http/responses.ts
+var responses_exports = /* @__PURE__ */ __exportAll({
+	filterError: () => filterError,
+	filterSuccess: () => filterSuccess,
+	findPrimary: () => findPrimary,
+	getImportedNames: () => getImportedNames
+});
+/** The `4xx` and `5xx` responses, ranges included. */
+function filterError(node) {
+	return node.responses.filter((response) => isError(response.statusCode));
+}
+/** The ref names the response bodies import, in order, with repeats. */
+function getImportedNames(responses) {
+	return responses.flatMap((response) => (response.content ?? []).flatMap((entry) => entry.schema ? collectImportedRefNames$1(entry.schema) : []));
+}
+function filterSuccess(node) {
+	return node.responses.filter((response) => isSuccess(response.statusCode));
+}
+/** The success response a client returns: one with a body first, then an exact code over a `2xx` range. */
+function findPrimary(node) {
+	const responses = filterSuccess(node);
+	const withBody = responses.filter((response) => response.content?.some((entry) => entry.contentType));
+	const candidates = withBody.length ? withBody : responses;
+	return candidates.find((response) => !Number.isNaN(Number(response.statusCode))) ?? candidates[0] ?? null;
+}
+// src/http/index.ts
+var http_exports = /* @__PURE__ */ __exportAll({
+	getBaseURL: () => getBaseURL,
+	groupParameters: () => groupParameters,
+	isOperation: () => isHttpOperationNode$1,
+	requestBody: () => requestBody_exports,
+	responses: () => responses_exports,
+	status: () => status_exports
+});
+/** The server's URL when it is absolute and has no template variables, else `undefined`. */
+function getBaseURL(server) {
+	if (!server || server.variables || server.url.includes("{") || !server.url.includes("://")) return void 0;
+	return URL.canParse(server.url) ? server.url : void 0;
+}
+const parametersByNode = /* @__PURE__ */ new WeakMap();
+/** The operation's parameters by location, with a `querystring` parameter in `query`. A repeated name keeps its first parameter. */
+function groupParameters(node) {
+	const cached = parametersByNode.get(node);
+	if (cached) return cached;
+	const group = (...locations) => {
+		const seen = /* @__PURE__ */ new Set();
+		return locations.flatMap((location) => node.parameters.filter((param) => {
+			if (param.in !== location || seen.has(param.name)) return false;
+			seen.add(param.name);
+			return true;
+		}));
+	};
+	const groups = {
+		path: group("path"),
+		query: group("query", "querystring"),
+		header: group("header"),
+		cookie: group("cookie")
+	};
+	parametersByNode.set(node, groups);
+	return groups;
+}
+// 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`, `not`, `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"
+};
+function createSchema(props) {
+	if (props.type === "object") return {
+		properties: [],
+		primitive: "object",
+		...props,
+		kind: nodeKinds$1.schema
+	};
 	return {
-		...schema,
-		optional: !required && !nullable ? true : void 0,
-		nullish: !required && nullable ? true : void 0
+		primitive: TYPE_TO_PRIMITIVE[props.type],
+		...props,
+		kind: nodeKinds$1.schema
 	};
 }
+// src/ref/index.ts
+var ref_exports = /* @__PURE__ */ __exportAll({
+	getName: () => getName,
+	getSchema: () => resolveRef$1,
+	isAlias: () => isBareRef$1,
+	mergeSchema: () => mergeSchema
+});
+/** A resolved ref merged with its target schema, so usage-site fields such as `description` win. Other nodes come back unchanged. */
+function mergeSchema(node) {
+	const ref = narrowSchema$1(node, "ref");
+	return ref?.schema ? createSchema(mergeRefWithSchema$1(ref)) : node;
+}
+function getName(input) {
+	return typeof input === "string" ? refName$1(input) : resolveRefName$1(input);
+}
 // src/createPrinter.ts
 /**
 * Creates a schema printer: a function that takes a `SchemaNode` and emits
@@ -627,9 +1131,9 @@ function optionality(schema, required) {
 *
 * @example Tiny Zod printer
 * ```ts
-* import { createPrinter, type PrinterFactoryOptions } from '@kubb/ast'
+* import { ast, createPrinter } from '@kubb/kit'
 *
-* type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
+* type PrinterZod = ast.PrinterFactoryOptions<'zod', { strict?: boolean }, string>
 *
 * export const zodPrinter = createPrinter<PrinterZod>((options) => ({
 *   name: 'zod',
@@ -646,7 +1150,7 @@ function optionality(schema, required) {
 * }))
 * ```
 */
-function createPrinter(build) {
+function createPrinter$1(build) {
 	return (options) => {
 		const { name, options: resolvedOptions, nodes, overrides, print: printOverride } = build(options ?? {});
 		const merged = overrides ? {
@@ -676,60 +1180,168 @@ function createPrinter(build) {
 		};
 	};
 }
-// src/utils/extractStringsFromNodes.ts
-const CODE_NODE_TEXT_FIELDS = {
-	Text: ["value"],
-	Jsx: ["value"],
-	Function: [
-		"params",
-		"generics",
-		"returnType"
-	],
-	ArrowFunction: [
-		"params",
-		"generics",
-		"returnType"
-	],
-	Const: ["type"]
-};
+__name(createPrinter$1, "createPrinter");
+// src/defineMacro.ts
 /**
-* Extracts all string content from a `CodeNode` tree recursively.
-*
-* Collects the text fields and nested node content, to build the source string for import filtering.
+* Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain
+* list keeps its authored order.
 */
-function extractStringsFromNodes(nodes) {
-	if (!nodes?.length) return "";
-	const collected = [];
-	for (const node of nodes) {
-		if (typeof node === "string") {
-			if (node) collected.push(node);
-			continue;
-		}
-		if (node.kind === nodeKinds.break) continue;
-		const parts = [];
-		const record = node;
-		for (const field of CODE_NODE_TEXT_FIELDS[node.kind] ?? []) {
-			const value = record[field];
-			if (Array.isArray(value)) parts.push(value.join(", "));
-			if (typeof value === "string" && value) parts.push(value);
-		}
-		const nested = "nodes" in node ? extractStringsFromNodes(node.nodes) : "";
-		if (nested) parts.push(nested);
-		if (parts.length) collected.push(parts.join("\n"));
-	}
-	return collected.join("\n");
+function enforceWeight(enforce) {
+	if (enforce === "pre") return 0;
+	if (enforce === "post") return 2;
+	return 1;
 }
-// src/utils/combineFileMembers.ts
 /**
-* File-member merging. `combineImports` and `combineExports` deduplicate and sort the import and
-* export entries of one file, while `combineSources` deduplicates source entries in original order.
-* `combineImports` also drops imports nothing references. This works on a file's members, not on
-* schema content.
+* Compares two `enforce` hints for `Array.prototype.sort`: `pre` first, unmarked next, `post`
+* last. Equal hints compare as `0`, so a stable sort keeps authored order within a bucket.
+*
+* @example
+* `plugins.sort((a, b) => compareMacroOrder(a.enforce, b.enforce))`
 */
-const IDENTIFIER_RUN = /[\w$]+/g;
+function compareMacroOrder(a, b) {
+	return enforceWeight(a) - enforceWeight(b);
+}
 /**
-* How many imports a file needs before indexing the source beats scanning it once per name.
-*/
+* Types a macro for inference and a single construction site, mirroring `defineExtension`.
+* Adds no runtime behavior.
+*
+* @example
+* ```ts
+* const macroUntagged = defineMacro({
+*   name: 'untagged',
+*   operation(node) {
+*     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }
+*   },
+* })
+* ```
+*/
+function defineMacro$1(macro) {
+	return macro;
+}
+__name(defineMacro$1, "defineMacro");
+/**
+* Runs every macro's callback for one node kind in order, chaining the result so each macro sees
+* the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the
+* original reference (structural sharing).
+*/
+function chain({ macros, key, node, context }) {
+	let current = node;
+	for (const macro of macros) {
+		const callback = macro[key];
+		if (!callback) continue;
+		if (macro.match && !macro.match(current)) continue;
+		const next = callback(current, context);
+		if (next != null) current = next;
+	}
+	return current === node ? void 0 : current;
+}
+/**
+* Folds an ordered list of macros into a single {@link Visitor} for `transform`. Macros are
+* stable-sorted by `enforce`, then applied sequentially per node so later macros see earlier output.
+*/
+function composeMacros(macros) {
+	const ordered = [...macros].sort((a, b) => compareMacroOrder(a.enforce, b.enforce));
+	const visitor = {};
+	for (const key of visitorKeys) {
+		if (!ordered.some((macro) => typeof macro[key] === "function")) continue;
+		const callback = (node, context) => chain({
+			macros: ordered,
+			key,
+			node,
+			context
+		});
+		visitor[key] = callback;
+	}
+	return visitor;
+}
+/**
+* Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s
+* structural sharing, so an empty or no-op macro list returns the same reference. Pass
+* `depth: 'shallow'` to rewrite the root node only.
+*
+* @example
+* ```ts
+* const next = applyMacros(root, [macroIntegerToString])
+* ```
+*
+* @example Apply to the root node only
+* ```ts
+* const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })
+* ```
+*/
+function applyMacros$1(root, macros, options) {
+	if (macros.length === 0) return root;
+	return transform$1(root, {
+		...composeMacros(macros),
+		...options
+	});
+}
+__name(applyMacros$1, "applyMacros");
+// src/macro/index.ts
+var macro_exports = /* @__PURE__ */ __exportAll({
+	apply: () => applyMacros$1,
+	compareOrder: () => compareMacroOrder
+});
+// src/utils/nodeText.ts
+const CODE_NODE_TEXT_FIELDS = {
+	Text: ["value"],
+	Jsx: ["value"],
+	Function: [
+		"params",
+		"generics",
+		"returnType"
+	],
+	ArrowFunction: [
+		"params",
+		"generics",
+		"returnType"
+	],
+	Const: ["type"]
+};
+/**
+* Extracts all string content from a `CodeNode` tree recursively.
+* Collects the text fields and nested node content, to build the source string for import filtering.
+*/
+function getNodeText(nodes) {
+	if (!nodes?.length) return "";
+	const collected = [];
+	for (const node of nodes) {
+		if (typeof node === "string") {
+			if (node) collected.push(node);
+			continue;
+		}
+		if (node.kind === nodeKinds$1.break) continue;
+		const parts = [];
+		const record = node;
+		for (const field of CODE_NODE_TEXT_FIELDS[node.kind] ?? []) {
+			const value = record[field];
+			if (Array.isArray(value)) parts.push(value.join(", "));
+			if (typeof value === "string" && value) parts.push(value);
+		}
+		const nested = "nodes" in node ? getNodeText(node.nodes) : "";
+		if (nested) parts.push(nested);
+		if (parts.length) collected.push(parts.join("\n"));
+	}
+	return collected.join("\n");
+}
+// src/node/index.ts
+var node_exports = /* @__PURE__ */ __exportAll({
+	collect: () => collect$1,
+	getText: () => getNodeText,
+	kinds: () => nodeKinds$1,
+	transform: () => transform$1
+});
+// src/utils/combineFileMembers.ts
+/**
+* File-member merging. `combineImports` and `combineExports` deduplicate and sort the import and
+* export entries of one file, while `combineSources` deduplicates source entries in original order.
+* `combineImports` also drops imports nothing references. This works on a file's members, not on
+* schema content.
+*/
+const IDENTIFIER_RUN = /[\w$]+/g;
+/**
+* How many imports a file needs before indexing the source beats scanning it once per name.
+*/
 const INDEX_ABOVE_IMPORTS = 128;
 /**
 * Returns the local binding an import name item introduces: the alias when there is one, else the
@@ -898,7 +1510,7 @@ function nodeFactory(kind) {
 * // import { useState } from 'react'
 * ```
 */
-const createImport = nodeFactory(nodeKinds.import);
+const createImport = nodeFactory(nodeKinds$1.import);
 /**
 * Creates an `ExportNode` representing a language-agnostic export/public API declaration.
 *
@@ -908,7 +1520,7 @@ const createImport = nodeFactory(nodeKinds.import);
 * // export { Pet } from './Pet'
 * ```
 */
-const createExport = nodeFactory(nodeKinds.export);
+const createExport = nodeFactory(nodeKinds$1.export);
 /**
 * Creates a `SourceNode` representing a fragment of source code within a file.
 *
@@ -917,7 +1529,7 @@ const createExport = nodeFactory(nodeKinds.export);
 * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
 * ```
 */
-const createSource = nodeFactory(nodeKinds.source);
+const createSource = nodeFactory(nodeKinds$1.source);
 /**
 * Creates a fully resolved `FileNode` from a file input descriptor.
 *
@@ -966,7 +1578,7 @@ function createFile(input) {
 		const sourceParts = [];
 		const localNames = /* @__PURE__ */ new Set();
 		for (const item of resolvedSources) {
-			const extracted = item.nodes && extractStringsFromNodes(item.nodes);
+			const extracted = item.nodes && getNodeText(item.nodes);
 			if (extracted) sourceParts.push(extracted);
 			if (item.name) localNames.add(item.name);
 		}
@@ -984,7 +1596,7 @@ function createFile(input) {
 	})();
 	return {
 		...input,
-		kind: nodeKinds.file,
+		kind: nodeKinds$1.file,
 		id: (0, node_crypto.hash)("sha256", input.path, "hex"),
 		name: node_path.default.basename(input.baseName, extname),
 		extname,
@@ -999,7 +1611,7 @@ function createFile(input) {
 * Replaces every name a file imports from a virtual file (one whose sources are all inline, so it is never written) with that name's
 * `inline.expression`, until no inline names are left. The definitions' own imports move to the importing file.
 */
-function inlineFiles(files, { language }) {
+function inlineFiles$1(files, { language }) {
 	const virtualFiles = new Map(files.filter((file) => file.sources.length > 0 && file.sources.every((source) => source.inline)).map((file) => [file.path, file]));
 	const result = {
 		files: [],
@@ -1050,415 +1662,148 @@ function inlineFiles(files, { language }) {
 				}
 				imports.push(...definition.imports);
 				return lang.wrap(definition.expression);
-			}),
-			used
-		};
-	}
-	function findTarget(file, local) {
-		if (virtualFiles.has(file.path) && file.sources.some((source) => source.name === local)) return {
-			path: file.path,
-			name: local
-		};
-		for (const imp of file.imports) {
-			const item = virtualFiles.has(imp.path) && [imp.name].flat().find((item) => importLocalName(item) === local);
-			if (item) return {
-				path: imp.path,
-				name: typeof item === "string" ? item : item.propertyName
-			};
-		}
-	}
-	for (const file of files) {
-		if (virtualFiles.has(file.path) || !file.imports.some((imp) => virtualFiles.has(imp.path))) continue;
-		const lang = language(file);
-		if (!lang) {
-			result.problems.push({
-				path: file.path,
-				message: `No parser for "${file.extname}" files supports inline sources.`
-			});
-			continue;
-		}
-		const carried = [];
-		const sources = file.sources.map((source) => ({
-			...source,
-			nodes: rewriteNodes(source.nodes, (text) => replaceNames(text, file, lang, carried).text)
-		}));
-		const imports = [...file.imports.filter((imp) => !virtualFiles.has(imp.path)), ...carried.map((imp) => imp.root ? {
-			...imp,
-			root: file.path
-		} : imp)];
-		result.files.push(createFile({
-			...file,
-			sources,
-			imports
-		}));
-	}
-	return result;
-}
-function pickNames(imp, used) {
-	if (!Array.isArray(imp.name)) return used.has(imp.name) ? [imp] : [];
-	const name = imp.name.filter((item) => used.has(importLocalName(item)));
-	return name.length > 0 ? [{
-		...imp,
-		name
-	}] : [];
-}
-function rewriteNodes(nodes, rewrite) {
-	return nodes?.map((node) => {
-		if (typeof node === "string") return rewrite(node);
-		if (node.kind === nodeKinds.break) return node;
-		const next = { ...node };
-		for (const field of CODE_NODE_TEXT_FIELDS[node.kind] ?? []) {
-			const value = next[field];
-			if (Array.isArray(value)) next[field] = value.map(rewrite);
-			if (typeof value === "string" && value) next[field] = rewrite(value);
-		}
-		if ("nodes" in node && node.nodes) next.nodes = rewriteNodes(node.nodes, rewrite);
-		return next;
-	});
-}
-// src/utils/refs.ts
-/**
-* Returns the last segment of a `$ref` pointer, for example `'Pet'` for `#/components/schemas/Pet`.
-* The segment is decoded like the pointer resolver does: percent-escapes first, then `~1` and `~0`
-* (RFC 6901), so `a~1b~0c` names the component `a/b~c`.
-*/
-function refName(ref) {
-	const cached = refNames.get(ref);
-	if (cached !== void 0) return cached;
-	const segment = ref.split("/").at(-1) ?? ref;
-	let decoded = segment;
-	try {
-		decoded = decodeURIComponent(segment);
-	} catch {}
-	const name = decoded.replaceAll("~1", "/").replaceAll("~0", "~");
-	if (refNames.size >= memoLimit) refNames.clear();
-	refNames.set(ref, name);
-	return name;
-}
-const refNames = /* @__PURE__ */ new Map();
-const memoLimit = 1e5;
-/**
-* Resolves the emitted name of the schema a ref node points at. Prefers `targetName` (set when
-* the referenced schema was renamed, e.g. to break a collision), then the last segment of `ref`,
-* then `name`, then the nested `schema.name`.
-*
-* Returns `null` for non-ref nodes or when no name resolves.
-*
-* @example
-* `resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' }) // 'Pet'`
-*
-* @example Collision-renamed target
-* `resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Order', targetName: 'OrderSchema' }) // 'OrderSchema'`
-*/
-function resolveRefName(node) {
-	if (!node || node.type !== "ref") return null;
-	if (node.targetName) return node.targetName;
-	if (node.ref) return refName(node.ref);
-	return node.name ?? node.schema?.name ?? null;
-}
-/**
-* Follows a resolved ref chain to its target schema. Returns an unresolved or cyclic ref as is.
-*
-* @example
-* ```ts
-* const target = resolveRef(refSchema)
-* ```
-*/
-function resolveRef(node) {
-	if (node.type !== "ref" || !node.schema) return node;
-	const seen = /* @__PURE__ */ new WeakSet();
-	let current = node;
-	while (current.type === "ref" && current.schema) {
-		if (seen.has(current)) return current;
-		seen.add(current);
-		current = current.schema;
-	}
-	return current;
-}
-/** Fields of a ref node that describe the ref itself, so they never override the resolved schema. */
-const REF_OWN_KEYS = /* @__PURE__ */ new Set([
-	"kind",
-	"type",
-	"name",
-	"ref",
-	"schema"
-]);
-/**
-* Merges a ref node with its resolved schema, giving the fields set at the usage site precedence.
-*
-* Every field on the ref except `kind`, `type`, `name`, `ref`, and `schema` overrides the same field
-* of the resolved `schema` (for example `description`, `nullable`, `readOnly`, `deprecated`). Fields
-* left `undefined` on the ref do not shadow the resolved schema. A ref without a resolved `schema`
-* is returned as is.
-*
-* @example
-* ```ts
-* const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A pet', schema: petSchema })
-* mergeRefWithSchema(ref) // petSchema's fields with description 'A pet'
-* ```
-*/
-function mergeRefWithSchema(node) {
-	if (!node.schema) return node;
-	const merged = { ...node.schema };
-	for (const key of Object.keys(node)) {
-		const value = node[key];
-		if (value !== void 0 && !REF_OWN_KEYS.has(key)) merged[key] = value;
-	}
-	return merged;
-}
-/**
-* Returns `true` when a schema is a bare ref without modifiers, metadata, or omit keys.
-*
-* Modifiers inherited from the resolved schema are included in the check because a ref emits the
-* referenced schema variable with those modifiers already applied.
-*/
-function isBareRef(node, keysToOmit) {
-	if (!node || node.type !== "ref") return false;
-	const meta = mergeRefWithSchema(node);
-	return !meta.nullable && !meta.optional && !meta.nullish && meta.default === void 0 && !meta.description && !meta.examples?.length && !keysToOmit?.length;
-}
-// ../../internals/utils/src/promise.ts
-/**
-* Returns the value cached under `key` in `store`, computing and storing it on the first call.
-* Pass a `WeakMap` for object keys, so an entry goes away with its key, or a `Map` for primitive
-* keys. A cached `null` or `undefined` counts as a hit, so `compute` runs once per key.
-*
-* @example
-* `const refs = memo(refCache, node, () => collectRefs(node))`
-*/
-function memo(store, key, compute) {
-	if (store.has(key)) return store.get(key);
-	const value = compute();
-	store.set(key, value);
-	return value;
-}
-// src/utils/schemaGraph.ts
-const refEntries = /* @__PURE__ */ new WeakMap();
-const checkRefEntries = /* @__PURE__ */ new WeakMap();
-const schemaRefs = /* @__PURE__ */ new WeakMap();
-const importedRefNames = /* @__PURE__ */ new WeakMap();
-const importedCheckRefNames = /* @__PURE__ */ new WeakMap();
-/**
-* Walks a node's subtree once and lists every ref it holds, in traversal order, as the resolved
-* name plus whether the ref carries a `$ref` pointer. Memoized per node and per `checks` mode, so
-* each helper below scans a schema once.
-*/
-function collectRefEntries(node, { checks }) {
-	return memo(checks ? checkRefEntries : refEntries, node, () => {
-		const entries = [];
-		const walk = (current) => {
-			if (current.kind === nodeKinds.schema && current.type === "ref") {
-				const name = resolveRefName(current);
-				if (name) entries.push({
-					name,
-					hasPointer: Boolean(current.ref)
-				});
-			}
-			visitChildNodes(current, walk, { checks });
-			return false;
-		};
-		walk(node);
-		return entries;
-	});
-}
-/**
-* Collects the names of every schema a node's subtree references, resolved with `resolveRefName`.
-* Each ref contributes its name only, so the schema it points to is never traversed. Memoized by
-* node identity, which lets `findCircularSchemas` and `containsCircularRef` share one scan per schema.
-*
-* @example
-* ```ts
-* collectSchemaRefs(petSchema)
-* // Set { 'Category', 'Tag' }
-* ```
-*/
-function collectSchemaRefs(node) {
-	return memo(schemaRefs, node, () => new Set(collectRefEntries(node, { checks: true }).map((entry) => entry.name)));
-}
-/**
-* Collects the de-duplicated target names of every pointer-carrying ref in a node's subtree, in
-* first-occurrence order. Memoized by node identity, so `resolver.imports` reads the same result
-* across the ts, zod, and faker plugins instead of re-scanning the same schema per plugin.
-*
-* Only refs that carry a `$ref` pointer count, so a synthesized ref pointing at a sibling in the
-* same file (a union member created by name) is left out. That leaves exactly the set
-* `resolver.imports` emits. Refs inside `conditionals`, `contains` and `content` count only with
-* `checks: true`, for a plugin that prints those checks.
-*
-* @example
-* ```ts
-* collectImportedRefNames(petSchema)
-* // ['Category', 'Tag']
-* ```
-*/
-function collectImportedRefNames(node, { checks = false } = {}) {
-	return memo(checks ? importedCheckRefNames : importedRefNames, node, () => [...new Set(collectRefEntries(node, { checks }).flatMap((entry) => entry.hasPointer ? [entry.name] : []))]);
-}
-/**
-* Collects the names of all top-level schemas transitively used by a set of operations.
-*
-* An operation uses a schema when its parameters, request body, or responses reference it, directly
-* or through other named schemas. Once a name is added to the result it is not revisited, so
-* reference cycles terminate.
-*
-* Pair it with `include` filters so schemas reachable only from excluded operations stay ungenerated.
-*
-* @example Only generate schemas referenced by included operations
-* ```ts
-* const includedOps = operations.filter((op) => resolver.default.options(op, { options, include }) !== null)
-* const allowed = collectUsedSchemaNames(includedOps, schemas)
-*
-* for (const schema of schemas) {
-*   if (schema.name && !allowed.has(schema.name)) continue
-*   // generate schema
-* }
-* ```
-*/
-function collectUsedSchemaNames(operations, schemas) {
-	const schemaMap = /* @__PURE__ */ new Map();
-	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
-	const result = /* @__PURE__ */ new Set();
-	function visitSchema(schema) {
-		for (const name of collectSchemaRefs(schema)) if (!result.has(name)) {
-			result.add(name);
-			const namedSchema = schemaMap.get(name);
-			if (namedSchema) visitSchema(namedSchema);
-		}
+			}),
+			used
+		};
 	}
-	for (const op of operations) for (const schema of collect(op, {
-		depth: "shallow",
-		schema: (node) => node
-	})) visitSchema(schema);
-	return result;
-}
-/**
-* Finds every schema that takes part in a circular dependency chain, including direct self-loops.
-*
-* Wrap the returned schema positions in a deferred construct (a lazy getter or `z.lazy(() => …)`) so
-* the generated code does not recurse forever. Refs are followed by name only, so the walk stays
-* linear in the size of the schema graph.
-*
-* @note Call this once on the full graph, then check individual schemas with `containsCircularRef()`.
-*/
-function findCircularSchemas(schemas) {
-	const graph = /* @__PURE__ */ new Map();
-	for (const schema of schemas) if (schema.name) graph.set(schema.name, collectSchemaRefs(schema));
-	const circular = /* @__PURE__ */ new Set();
-	for (const start of graph.keys()) {
-		const visited = /* @__PURE__ */ new Set();
-		const stack = [...graph.get(start) ?? []];
-		while (stack.length > 0) {
-			const node = stack.pop();
-			if (node === start) {
-				circular.add(start);
-				break;
-			}
-			if (visited.has(node)) continue;
-			visited.add(node);
-			const next = graph.get(node);
-			if (next) for (const r of next) stack.push(r);
+	function findTarget(file, local) {
+		if (virtualFiles.has(file.path) && file.sources.some((source) => source.name === local)) return {
+			path: file.path,
+			name: local
+		};
+		for (const imp of file.imports) {
+			const item = virtualFiles.has(imp.path) && [imp.name].flat().find((item) => importLocalName(item) === local);
+			if (item) return {
+				path: imp.path,
+				name: typeof item === "string" ? item : item.propertyName
+			};
 		}
 	}
-	return circular;
-}
-// src/utils/schemaProperties.ts
-/**
-* Finds every matching property exposed by an object, resolved reference, or intersection.
-*
-* References are followed through their parsed `schema`. Circular references terminate without
-* revisiting a node. Unions are not traversed because a property on one branch does not describe
-* every branch.
-*
-* @example Faker discriminator narrowing
-* ```ts
-* const values = resolveSchemaProperties({ node: member, propertyName: union.discriminatorPropertyName }).flatMap(({ schema }) =>
-*   getSchemaLiteralValues(schema),
-* )
-* const typeName = `Extract<Pet, { type: ${values.map(JSON.stringify).join(' | ')} }>`
-* ```
-*
-* @example Zod discriminated unions
-* ```ts
-* const canDiscriminate = union.members?.every(
-*   (member) => resolveSchemaProperties({ node: member, propertyName: 'type' }).length > 0,
-* )
-* const expression = canDiscriminate ? `z.discriminatedUnion('type', members)` : `z.union(members)`
-* ```
-*
-* @example TypeScript property lookup
-* ```ts
-* const properties = resolveSchemaProperties({ node: schema, propertyName: 'status' })
-* const statusSchemas = properties.map((property) => print(property.schema))
-* ```
-*/
-function resolveSchemaProperties({ node, propertyName }) {
-	const properties = [];
-	walkSchema(node, "intersection", (current) => {
-		if (current.type !== "object") return;
-		const property = current.properties.find((candidate) => candidate.name === propertyName);
-		if (property) properties.push(property);
-	});
-	return properties;
-}
-function walkSchema(node, through, visit) {
-	const visited = /* @__PURE__ */ new WeakSet();
-	function walk(current) {
-		if (!current || visited.has(current)) return;
-		visited.add(current);
-		visit(current);
-		if (current.type === "ref") return walk(current.schema);
-		if (current.type === through) for (const member of current.members ?? []) walk(member);
+	for (const file of files) {
+		if (virtualFiles.has(file.path) || !file.imports.some((imp) => virtualFiles.has(imp.path))) continue;
+		const lang = language(file);
+		if (!lang) {
+			result.problems.push({
+				path: file.path,
+				message: `No parser for "${file.extname}" files supports inline sources.`
+			});
+			continue;
+		}
+		const carried = [];
+		const sources = file.sources.map((source) => ({
+			...source,
+			nodes: rewriteNodes(source.nodes, (text) => replaceNames(text, file, lang, carried).text)
+		}));
+		const imports = [...file.imports.filter((imp) => !virtualFiles.has(imp.path)), ...carried.map((imp) => imp.root ? {
+			...imp,
+			root: file.path
+		} : imp)];
+		result.files.push(createFile({
+			...file,
+			sources,
+			imports
+		}));
 	}
-	walk(node);
+	return result;
 }
-/**
-* Reads the unique literal values represented by an enum, resolved reference, or union.
-*
-* Named enum values take precedence over simple enum values, matching how renderers consume
-* `EnumSchemaNode`.
-*
-* @example
-* ```ts
-* const values = getSchemaLiteralValues(enumNode)
-* // ['cat', 'dog']
-* ```
-*/
-function getSchemaLiteralValues(node) {
-	const values = /* @__PURE__ */ new Set();
-	walkSchema(node, "union", (current) => {
-		if (current.type !== "enum") return;
-		for (const { value } of current.namedEnumValues ?? current.enumValues?.map((value) => ({ value })) ?? []) values.add(value);
-	});
-	return [...values];
+__name(inlineFiles$1, "inlineFiles");
+function pickNames(imp, used) {
+	if (!Array.isArray(imp.name)) return used.has(imp.name) ? [imp] : [];
+	const name = imp.name.filter((item) => used.has(importLocalName(item)));
+	return name.length > 0 ? [{
+		...imp,
+		name
+	}] : [];
 }
-function collectPropertyNames(node) {
-	const names = /* @__PURE__ */ new Set();
-	walkSchema(node, "intersection", (current) => {
-		if (current.type === "object") for (const property of current.properties) names.add(property.name);
+function rewriteNodes(nodes, rewrite) {
+	return nodes?.map((node) => {
+		if (typeof node === "string") return rewrite(node);
+		if (node.kind === nodeKinds$1.break) return node;
+		const next = { ...node };
+		for (const field of CODE_NODE_TEXT_FIELDS[node.kind] ?? []) {
+			const value = next[field];
+			if (Array.isArray(value)) next[field] = value.map(rewrite);
+			if (typeof value === "string" && value) next[field] = rewrite(value);
+		}
+		if ("nodes" in node && node.nodes) next.nodes = rewriteNodes(node.nodes, rewrite);
+		return next;
 	});
-	return names;
 }
-/**
-* Infers an implicit discriminator: a property every member exposes with a distinct single
-* literal value, the same shape a declared OpenAPI `discriminator` already narrows on.
-*/
-function inferDiscriminatorPropertyName(members) {
-	if (members.length < 2) return void 0;
-	let candidates;
-	for (const member of members) {
-		const names = collectPropertyNames(member);
-		candidates = candidates ? new Set([...candidates].filter((name) => names.has(name))) : names;
-	}
-	for (const name of candidates ?? []) {
-		const values = members.map((member) => {
-			const literals = new Set(resolveSchemaProperties({
-				node: member,
-				propertyName: name
-			}).flatMap((property) => getSchemaLiteralValues(property.schema)));
-			return literals.size === 1 ? [...literals][0] : void 0;
-		});
-		if (values.every((value) => value !== void 0) && new Set(values).size === members.length) return name;
+// src/file/index.ts
+var file_exports = /* @__PURE__ */ __exportAll({ inline: () => inlineFiles$1 });
+// src/deprecated.ts
+/** @deprecated Use `ast.ref.isAlias`. Removed in Kubb v6. */
+const isBareRef = isBareRef$1;
+/** @deprecated Use `ast.ref.mergeSchema`. Removed in Kubb v6. */
+const mergeRefWithSchema = mergeRefWithSchema$1;
+/** @deprecated Use `ast.ref.getName`. Removed in Kubb v6. */
+const refName = getName;
+/** @deprecated Use `ast.ref.getSchema`. Removed in Kubb v6. */
+const resolveRef = resolveRef$1;
+/** @deprecated Use `ast.ref.getName`. Removed in Kubb v6. */
+const resolveRefName = getName;
+/** @deprecated Use `ast.graph.getImportedNames`. Removed in Kubb v6. */
+const collectImportedRefNames = collectImportedRefNames$1;
+/** @deprecated Use `ast.graph.getRefNames`. Removed in Kubb v6. */
+const collectSchemaRefs = collectSchemaRefs$1;
+/** @deprecated Use `ast.graph.getUsedNames`. Removed in Kubb v6. */
+const collectUsedSchemaNames = collectUsedSchemaNames$1;
+/** @deprecated Use `ast.graph.getCircularNames`. Removed in Kubb v6. */
+const findCircularSchemas = findCircularSchemas$1;
+/** @deprecated Use `ast.schema.getLiterals`. Removed in Kubb v6. */
+const getSchemaLiteralValues = getSchemaLiteralValues$1;
+/** @deprecated Use `ast.schema.inferDiscriminator`. Removed in Kubb v6. */
+const inferDiscriminatorPropertyName = inferDiscriminatorPropertyName$1;
+/** @deprecated Use `ast.schema.findProperties`. Removed in Kubb v6. */
+const resolveSchemaProperties = resolveSchemaProperties$1;
+/** @deprecated Use `ast.http.isOperation`. Removed in Kubb v6. */
+const isHttpOperationNode = isHttpOperationNode$1;
+/** @deprecated Use `ast.node.collect`, which returns the same array. Removed in Kubb v6. */
+const collectSync = collect$1;
+/** @deprecated Use `ast.schema.applyOptionality`. Removed in Kubb v6. */
+const optionality = applyOptionality;
+/** @deprecated Use `ast.node.getText`. Removed in Kubb v6. */
+const extractStringsFromNodes = getNodeText;
+/** @deprecated Use `ast.macro.compareOrder`. Removed in Kubb v6. */
+const compareEnforce = compareMacroOrder;
+/** @deprecated Use `createPrinter` from `@kubb/kit`. Removed in Kubb v6. */
+const createPrinter = createPrinter$1;
+/** @deprecated Use `defineMacro` from `@kubb/kit`. Removed in Kubb v6. */
+const defineMacro = defineMacro$1;
+/** @deprecated Use `ast.macro.apply`. Removed in Kubb v6. */
+const applyMacros = applyMacros$1;
+/** @deprecated Use `ast.node.kinds`. Removed in Kubb v6. */
+const nodeKinds = nodeKinds$1;
+/** @deprecated Use `ast.schema.types`. Removed in Kubb v6. */
+const schemaTypes = schemaTypes$1;
+/** @deprecated Use `ast.schema.find`. Removed in Kubb v6. */
+const findSchema = findSchema$1;
+/** @deprecated Use `ast.schema.narrow`. Removed in Kubb v6. */
+const narrowSchema = narrowSchema$1;
+/** @deprecated Use `ast.node.transform`. Removed in Kubb v6. */
+const transform = transform$1;
+/** @deprecated Use `ast.node.collect`. Removed in Kubb v6. */
+const collect = collect$1;
+/** @deprecated Use `ast.file.inline`. Removed in Kubb v6. */
+const inlineFiles = inlineFiles$1;
+// src/auth/index.ts
+var auth_exports = /* @__PURE__ */ __exportAll({ getRequirements: () => getRequirements });
+/** Joins each requirement with its schemes. Drops undeclared and repeated requirements, and keeps an empty one (no auth needed). */
+function getRequirements({ auth, schemes }) {
+	const credentials = new Map(schemes?.map((scheme) => [scheme.name, scheme.credential]));
+	const seen = /* @__PURE__ */ new Set();
+	const resolved = [];
+	for (const requirement of auth ?? []) {
+		const key = requirement.map(({ scheme, scopes }) => [scheme, ...scopes ?? []].join(" ")).join("\0");
+		if (seen.has(key) || !requirement.every(({ scheme }) => credentials.has(scheme))) continue;
+		seen.add(key);
+		resolved.push(requirement.map(({ scheme, scopes }) => ({
+			name: scheme,
+			credential: credentials.get(scheme),
+			scopes: scopes ?? []
+		})));
 	}
+	return resolved;
 }
 // src/nodes/code.ts
 /**
@@ -1470,7 +1815,7 @@ function inferDiscriminatorPropertyName(members) {
 * // export const pets: Pet[] = ... as const
 * ```
 */
-const createConst = nodeFactory(nodeKinds.const);
+const createConst = nodeFactory(nodeKinds$1.const);
 /**
 * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
 *
@@ -1480,7 +1825,7 @@ const createConst = nodeFactory(nodeKinds.const);
 * // export type Pet = ...
 * ```
 */
-const createType = nodeFactory(nodeKinds.type);
+const createType = nodeFactory(nodeKinds$1.type);
 /**
 * Creates a `FunctionNode` representing a TypeScript `function` declaration.
 *
@@ -1490,7 +1835,7 @@ const createType = nodeFactory(nodeKinds.type);
 * // export async function fetchPet(): Promise<Pet> { ... }
 * ```
 */
-const createFunction = nodeFactory(nodeKinds.function);
+const createFunction = nodeFactory(nodeKinds$1.function);
 /**
 * Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
 *
@@ -1500,7 +1845,7 @@ const createFunction = nodeFactory(nodeKinds.function);
 * // export const double = (n: number) => ...
 * ```
 */
-const createArrowFunction = nodeFactory(nodeKinds.arrowFunction);
+const createArrowFunction = nodeFactory(nodeKinds$1.arrowFunction);
 /**
 * Creates a {@link TextNode} representing a raw string fragment in the source output.
 *
@@ -1512,7 +1857,7 @@ const createArrowFunction = nodeFactory(nodeKinds.arrowFunction);
 */
 function createText(value) {
 	return {
-		kind: nodeKinds.text,
+		kind: nodeKinds$1.text,
 		value
 	};
 }
@@ -1526,7 +1871,7 @@ function createText(value) {
 * ```
 */
 function createBreak() {
-	return { kind: nodeKinds.break };
+	return { kind: nodeKinds$1.break };
 }
 /**
 * Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
@@ -1539,7 +1884,7 @@ function createBreak() {
 */
 function createJsx(value) {
 	return {
-		kind: nodeKinds.jsx,
+		kind: nodeKinds$1.jsx,
 		value
 	};
 }
@@ -1547,7 +1892,7 @@ function createJsx(value) {
 /**
 * Creates a `ContentNode` for a single request-body or response content type.
 */
-const createContent = nodeFactory(nodeKinds.content);
+const createContent = nodeFactory(nodeKinds$1.content);
 // src/nodes/input.ts
 /**
 * Creates an `InputNode`, defaulting `schemas`/`operations` to empty arrays and `meta` to an empty
@@ -1565,14 +1910,14 @@ function createInput(overrides = {}) {
 		operations: [],
 		meta: {},
 		...overrides,
-		kind: nodeKinds.input
+		kind: nodeKinds$1.input
 	};
 }
 // src/nodes/requestBody.ts
 /**
 * Creates a `RequestBodyNode`.
 */
-const createRequestBody = nodeFactory(nodeKinds.requestBody);
+const createRequestBody = nodeFactory(nodeKinds$1.requestBody);
 // src/nodes/operation.ts
 function createOperation(props) {
 	const { requestBody, ...rest } = props;
@@ -1582,7 +1927,7 @@ function createOperation(props) {
 		parameters: [],
 		responses: [],
 		...rest,
-		kind: nodeKinds.operation,
+		kind: nodeKinds$1.operation,
 		...isHttp ? { protocol: "http" } : {},
 		requestBody: requestBody ? createRequestBody(requestBody) : void 0
 	};
@@ -1607,8 +1952,8 @@ function createParameter(input) {
 	return {
 		...input,
 		required,
-		schema: optionality(input.schema, required),
-		kind: nodeKinds.parameter
+		schema: applyOptionality(input.schema, required),
+		kind: nodeKinds$1.parameter
 	};
 }
 // src/nodes/property.ts
@@ -1631,8 +1976,8 @@ function createProperty(input) {
 	return {
 		...input,
 		required,
-		schema: optionality(input.schema, required),
-		kind: nodeKinds.property
+		schema: applyOptionality(input.schema, required),
+		kind: nodeKinds$1.property
 	};
 }
 // src/nodes/response.ts
@@ -1658,46 +2003,7 @@ function createResponse(props) {
 	return {
 		...rest,
 		content: entries,
-		kind: nodeKinds.response
-	};
-}
-// 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`, `not`, `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"
-};
-function createSchema(props) {
-	if (props.type === "object") return {
-		properties: [],
-		primitive: "object",
-		...props,
-		kind: nodeKinds.schema
-	};
-	return {
-		primitive: TYPE_TO_PRIMITIVE[props.type],
-		...props,
-		kind: nodeKinds.schema
+		kind: nodeKinds$1.response
 	};
 }
 // src/nodes/index.ts
@@ -1722,10 +2028,26 @@ var nodes_exports = /* @__PURE__ */ __exportAll({
 	createText: () => createText,
 	createType: () => createType
 });
+// src/server/index.ts
+var server_exports = /* @__PURE__ */ __exportAll({
+	get: () => get,
+	groupByName: () => groupByName
+});
+/** The server at `index`, else the first one. */
+function get({ servers, index = 0 }) {
+	return servers?.[index] ?? servers?.[0];
+}
+/** Named servers by name. The first server with a name wins. */
+function groupByName(servers) {
+	const named = /* @__PURE__ */ new Map();
+	for (const server of servers ?? []) if (server.name && !named.has(server.name)) named.set(server.name, server);
+	return named;
+}
 // src/index.ts
 var src_exports = /* @__PURE__ */ __exportAll({
 	applyMacros: () => applyMacros,
 	ast: () => src_exports,
+	auth: () => auth_exports,
 	collect: () => collect,
 	collectImportedRefNames: () => collectImportedRefNames,
 	collectSchemaRefs: () => collectSchemaRefs,
@@ -1736,22 +2058,31 @@ var src_exports = /* @__PURE__ */ __exportAll({
 	defineMacro: () => defineMacro,
 	extractStringsFromNodes: () => extractStringsFromNodes,
 	factory: () => nodes_exports,
+	file: () => file_exports,
 	findCircularSchemas: () => findCircularSchemas,
 	findSchema: () => findSchema,
 	getSchemaLiteralValues: () => getSchemaLiteralValues,
+	graph: () => graph_exports,
+	http: () => http_exports,
 	inferDiscriminatorPropertyName: () => inferDiscriminatorPropertyName,
 	inlineFiles: () => inlineFiles,
 	isBareRef: () => isBareRef,
 	isHttpOperationNode: () => isHttpOperationNode,
+	macro: () => macro_exports,
+	mediaType: () => mediaType_exports,
 	mergeRefWithSchema: () => mergeRefWithSchema,
 	narrowSchema: () => narrowSchema,
+	node: () => node_exports,
 	nodeKinds: () => nodeKinds,
 	optionality: () => optionality,
+	ref: () => ref_exports,
 	refName: () => refName,
 	resolveRef: () => resolveRef,
 	resolveRefName: () => resolveRefName,
 	resolveSchemaProperties: () => resolveSchemaProperties,
+	schema: () => schema_exports,
 	schemaTypes: () => schemaTypes,
+	server: () => server_exports,
 	transform: () => transform
 });
 exports.applyMacros = applyMacros;
@@ -1761,6 +2092,12 @@ Object.defineProperty(exports, "ast", {
 		return src_exports;
 	}
 });
+Object.defineProperty(exports, "auth", {
+	enumerable: true,
+	get: function() {
+		return auth_exports;
+	}
+});
 exports.collect = collect;
 exports.collectImportedRefNames = collectImportedRefNames;
 exports.collectSchemaRefs = collectSchemaRefs;
@@ -1776,22 +2113,76 @@ Object.defineProperty(exports, "factory", {
 		return nodes_exports;
 	}
 });
+Object.defineProperty(exports, "file", {
+	enumerable: true,
+	get: function() {
+		return file_exports;
+	}
+});
 exports.findCircularSchemas = findCircularSchemas;
 exports.findSchema = findSchema;
 exports.getSchemaLiteralValues = getSchemaLiteralValues;
+Object.defineProperty(exports, "graph", {
+	enumerable: true,
+	get: function() {
+		return graph_exports;
+	}
+});
+Object.defineProperty(exports, "http", {
+	enumerable: true,
+	get: function() {
+		return http_exports;
+	}
+});
 exports.inferDiscriminatorPropertyName = inferDiscriminatorPropertyName;
 exports.inlineFiles = inlineFiles;
 exports.isBareRef = isBareRef;
 exports.isHttpOperationNode = isHttpOperationNode;
+Object.defineProperty(exports, "macro", {
+	enumerable: true,
+	get: function() {
+		return macro_exports;
+	}
+});
+Object.defineProperty(exports, "mediaType", {
+	enumerable: true,
+	get: function() {
+		return mediaType_exports;
+	}
+});
 exports.mergeRefWithSchema = mergeRefWithSchema;
 exports.narrowSchema = narrowSchema;
+Object.defineProperty(exports, "node", {
+	enumerable: true,
+	get: function() {
+		return node_exports;
+	}
+});
 exports.nodeKinds = nodeKinds;
 exports.optionality = optionality;
+Object.defineProperty(exports, "ref", {
+	enumerable: true,
+	get: function() {
+		return ref_exports;
+	}
+});
 exports.refName = refName;
 exports.resolveRef = resolveRef;
 exports.resolveRefName = resolveRefName;
 exports.resolveSchemaProperties = resolveSchemaProperties;
+Object.defineProperty(exports, "schema", {
+	enumerable: true,
+	get: function() {
+		return schema_exports;
+	}
+});
 exports.schemaTypes = schemaTypes;
+Object.defineProperty(exports, "server", {
+	enumerable: true,
+	get: function() {
+		return server_exports;
+	}
+});
 exports.transform = transform;
 
 //# sourceMappingURL=index.cjs.map