@kubb/adapter-oas 5.0.0-beta.75 → 5.0.0-beta.76

package/dist/index.js

@@ -1,27 +1,28 @@
-import "./chunk--u3MIqq1.js";
-import { ast, createAdapter } from "@kubb/core";
+import "./rolldown-runtime-C0LytTxp.js";
+import { Diagnostics, ast, createAdapter } from "@kubb/core";
 import path from "node:path";
-import { bundle, loadConfig } from "@redocly/openapi-core";
-import OASNormalize from "oas-normalize";
-import swagger2openapi from "swagger2openapi";
-import BaseOas from "oas";
-import { isRef } from "oas/types";
-import { matchesMimeType } from "oas/utils";
+import { access, readFile } from "node:fs/promises";
+import { compileErrors, validate } from "@readme/openapi-parser";
+import { upgrade } from "@scalar/openapi-upgrader";
+import { parse } from "yaml";
+import { bundle } from "api-ref-bundler";
+import { macroDiscriminatorEnum, macroEnumName, macroSimplifyUnion } from "@kubb/ast/macros";
+import { childName, enumPropName, extractRefName, findCircularSchemas, mergeAdjacentObjectsLazy } from "@kubb/ast/utils";
+import { collect, narrowSchema } from "@kubb/ast";
 //#region src/constants.ts
 /**
 * Default parser options applied when no explicit options are provided.
 *
 * @example
 * ```ts
-* import { DEFAULT_PARSER_OPTIONS } from '@kubb/adapter-oas'
+* import { DEFAULT_PARSER_OPTIONS, parseOas } from '@kubb/adapter-oas'
 *
-* const parser = createOasParser(oas)
-* const root = parser.parse({ ...DEFAULT_PARSER_OPTIONS, dateType: 'date' })
+* const { root } = parseOas(document, { ...DEFAULT_PARSER_OPTIONS, dateType: 'date' })
 * ```
 */
 const DEFAULT_PARSER_OPTIONS = {
 	dateType: "string",
-	integerType: "number",
+	integerType: "bigint",
 	unknownType: "any",
 	emptySchemaType: "any",
 	enumSuffix: "enum"
@@ -38,17 +39,19 @@ const DEFAULT_PARSER_OPTIONS = {
 */
 const SCHEMA_REF_PREFIX = "#/components/schemas/";
 /**
-* OpenAPI version string written into the stub document created during multi-spec merges.
+* HTTP methods that count as operations on an OpenAPI path item. Other keys
+* (`parameters`, `summary`, `$ref`, vendor extensions) are skipped when iterating operations.
 */
-const MERGE_OPENAPI_VERSION = "3.0.0";
-/**
-* Fallback `info.title` placed in the stub document when merging multiple API files.
-*/
-const MERGE_DEFAULT_TITLE = "Merged API";
-/**
-* Fallback `info.version` placed in the stub document when merging multiple API files.
-*/
-const MERGE_DEFAULT_VERSION = "1.0.0";
+const SUPPORTED_METHODS = new Set([
+	"get",
+	"put",
+	"post",
+	"delete",
+	"options",
+	"head",
+	"patch",
+	"trace"
+]);
 /**
 * Set of JSON Schema keywords that prevent a schema fragment from being inlined during `allOf` flattening.
 *
@@ -73,12 +76,24 @@ const structuralKeys = new Set([
 	"not"
 ]);
 /**
+* Formats `convertFormat` maps to a dedicated type without going through `formatMap`:
+* `int64` and the date/time family. Keep this in sync with the `convertFormat`
+* special-cases in `parser.ts`. `isHandledFormat` reads it so the
+* `KUBB_UNSUPPORTED_FORMAT` diagnostic and the parser agree on what is handled.
+*/
+const specialCasedFormats = new Set([
+	"int64",
+	"date-time",
+	"date",
+	"time"
+]);
+/**
 * Static map from OAS `format` strings to Kubb `SchemaType` values.
 *
 * Only formats whose AST type differs from the OAS `type` field appear here.
-* Formats that depend on runtime options (`int64`, `date-time`, `date`, `time`) are handled separately
-* in the parser. `ipv4` and `ipv6` map to their own dedicated schema types; `hostname` and
-* `idn-hostname` map to `'url'` as the closest generic string-format type.
+* Formats that depend on runtime options (`int64`, `date-time`, `date`, `time`) are handled
+* separately in the parser. `ipv4` and `ipv6` map to their own dedicated schema types. `hostname`
+* and `idn-hostname` map to `'url'` as the closest generic string-format type.
 *
 * @example
 * ```ts
@@ -118,95 +133,16 @@ const formatMap = {
 */
 const enumExtensionKeys = ["x-enumNames", "x-enum-varnames"];
 /**
-* Maps `'any' | 'unknown' | 'void'` option strings to their `ScalarSchemaType` constant.
-* Replaces a plain object lookup with a `Map` for explicit key membership testing via `.has()`.
-*/
-const typeOptionMap = new Map([
-	["any", ast.schemaTypes.any],
-	["unknown", ast.schemaTypes.unknown],
-	["void", ast.schemaTypes.void]
-]);
-//#endregion
-//#region src/discriminator.ts
-/**
-* Injects discriminator enum values into child schemas so they know which value identifies them.
-*
-* Finds every union schema in `input.schemas` that has a `discriminatorPropertyName`, collects the
-* enum value each union member is mapped to, then adds (or replaces) that property on the matching
-* child object schema.
-*
-* Returns a new `InputNode` — the original is never mutated.
+* Vendor extension keys that attach human-readable descriptions to enum values, checked in priority order.
 *
 * @example
 * ```ts
-* const { root } = parseOas(document, options)
-* const next = applyDiscriminatorInheritance(root)
+* import { enumDescriptionKeys } from '@kubb/adapter-oas'
+*
+* const key = enumDescriptionKeys.find((k) => k in schema) // 'x-enumDescriptions' | 'x-enum-descriptions' | undefined
 * ```
 */
-function applyDiscriminatorInheritance(root) {
-	const childMap = /* @__PURE__ */ new Map();
-	for (const schema of root.schemas) {
-		let unionNode = ast.narrowSchema(schema, "union");
-		if (!unionNode) {
-			const intersectionMembers = ast.narrowSchema(schema, "intersection")?.members;
-			if (intersectionMembers) for (const m of intersectionMembers) {
-				const u = ast.narrowSchema(m, "union");
-				if (u) {
-					unionNode = u;
-					break;
-				}
-			}
-		}
-		if (!unionNode?.discriminatorPropertyName || !unionNode.members) continue;
-		const { discriminatorPropertyName, members } = unionNode;
-		for (const member of members) {
-			const intersectionNode = ast.narrowSchema(member, "intersection");
-			if (!intersectionNode?.members) continue;
-			let refNode;
-			let objNode;
-			for (const m of intersectionNode.members) {
-				refNode ??= ast.narrowSchema(m, "ref");
-				objNode ??= ast.narrowSchema(m, "object");
-			}
-			if (!refNode?.name || !objNode) continue;
-			const prop = objNode.properties.find((p) => p.name === discriminatorPropertyName);
-			const enumNode = prop ? ast.narrowSchema(prop.schema, "enum") : void 0;
-			if (!enumNode?.enumValues?.length) continue;
-			const enumValues = enumNode.enumValues.filter((v) => v !== null);
-			if (!enumValues.length) continue;
-			const existing = childMap.get(refNode.name);
-			if (existing) existing.enumValues.push(...enumValues);
-			else childMap.set(refNode.name, {
-				propertyName: discriminatorPropertyName,
-				enumValues: [...enumValues]
-			});
-		}
-	}
-	if (childMap.size === 0) return root;
-	return ast.transform(root, { schema(node, { parent }) {
-		if (parent?.kind !== "Input" || !node.name) return;
-		const entry = childMap.get(node.name);
-		if (!entry) return;
-		const objectNode = ast.narrowSchema(node, "object");
-		if (!objectNode) return;
-		const { propertyName, enumValues } = entry;
-		const enumSchema = ast.createSchema({
-			type: "enum",
-			enumValues
-		});
-		const newProp = ast.createProperty({
-			name: propertyName,
-			required: true,
-			schema: enumSchema
-		});
-		const existingIdx = objectNode.properties.findIndex((p) => p.name === propertyName);
-		const newProperties = existingIdx >= 0 ? objectNode.properties.map((p, i) => i === existingIdx ? newProp : p) : [...objectNode.properties, newProp];
-		return {
-			...objectNode,
-			properties: newProperties
-		};
-	} });
-}
+const enumDescriptionKeys = ["x-enumDescriptions", "x-enum-descriptions"];
 //#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -219,356 +155,237 @@ function applyDiscriminatorInheritance(root) {
 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;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
 	}).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 /**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
-*
-* Only splits on dots followed by a letter so that version numbers
-* embedded in operationIds (e.g. `v2025.0`) are kept intact.
-*
-* Empty segments are filtered before joining. They arise when the text starts with
-* a dot followed immediately by a letter (e.g. `..Schema` splits into `['..', 'Schema']`
-* and `'..'` transforms to an empty string). Without this filter the join would produce
-* a leading `/`, which `path.resolve` would interpret as an absolute path, allowing
-* generated files to escape the configured output directory.
-*/
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).filter(Boolean).join("/");
-}
-/**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
-*
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
-*/
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
-}
-/**
 * Converts `text` to PascalCase.
-* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
 *
-* @example
-* pascalCase('hello-world')                  // 'HelloWorld'
-* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
-*/
-function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
-		prefix,
-		suffix
-	}) : camelCase(part));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
-}
-//#endregion
-//#region ../../internals/utils/src/object.ts
-/**
-* Returns `true` when `value` is a plain (non-null, non-array) object.
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
 *
-* @example
-* ```ts
-* isPlainObject({})          // true
-* isPlainObject([])          // false
-* isPlainObject(null)        // false
-* ```
-*/
-function isPlainObject(value) {
-	return typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype;
-}
-/**
-* Recursively merges `source` into `target`, combining nested plain objects.
-* Arrays and non-object values from `source` override the corresponding values in `target`.
-*
-* @example
-* ```ts
-* mergeDeep({ a: { x: 1 } }, { a: { y: 2 } })
-* // { a: { x: 1, y: 2 } }
-* ```
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
 */
-function mergeDeep(target, source) {
-	const result = { ...target };
-	for (const key of Object.keys(source)) {
-		const sv = source[key];
-		const tv = result[key];
-		result[key] = sv !== null && typeof sv === "object" && !Array.isArray(sv) && tv !== null && typeof tv === "object" && !Array.isArray(tv) ? mergeDeep(tv, sv) : sv;
-	}
-	return result;
-}
-//#endregion
-//#region ../../internals/utils/src/reserved.ts
-/**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
-*/
-const reservedWords = new Set([
-	"abstract",
-	"arguments",
-	"boolean",
-	"break",
-	"byte",
-	"case",
-	"catch",
-	"char",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"double",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"final",
-	"finally",
-	"float",
-	"for",
-	"function",
-	"goto",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"int",
-	"interface",
-	"let",
-	"long",
-	"native",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"short",
-	"static",
-	"super",
-	"switch",
-	"synchronized",
-	"this",
-	"throw",
-	"throws",
-	"transient",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"volatile",
-	"while",
-	"with",
-	"yield",
-	"Array",
-	"Date",
-	"hasOwnProperty",
-	"Infinity",
-	"isFinite",
-	"isNaN",
-	"isPrototypeOf",
-	"length",
-	"Math",
-	"name",
-	"NaN",
-	"Number",
-	"Object",
-	"prototype",
-	"String",
-	"toString",
-	"undefined",
-	"valueOf"
-]);
-/**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
-*
-* @example
-* ```ts
-* isValidVarName('status')  // true
-* isValidVarName('class')   // false (reserved word)
-* isValidVarName('42foo')   // false (starts with digit)
-* ```
-*/
-function isValidVarName(name) {
-	if (!name || reservedWords.has(name)) return false;
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
-//#region ../../internals/utils/src/urlPath.ts
+//#region ../../internals/utils/src/runtime.ts
 /**
-* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
+* Detects the JavaScript runtime executing the current process and exposes its name and version.
 *
-* @example
-* const p = new URLPath('/pet/{petId}')
-* p.URL      // '/pet/:petId'
-* p.template // '`/pet/${petId}`'
+* Prefer the shared {@link runtime} instance over constructing your own.
 */
-var URLPath = class {
+var Runtime = class {
 	/**
-	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
-	*/
-	path;
-	#options;
-	constructor(path, options = {}) {
-		this.path = path;
-		this.#options = options;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+	* `true` when the current process is running under Bun.
 	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').URL // '/pet/:petId'
-	* ```
-	*/
-	get URL() {
-		return this.toURLPath();
-	}
-	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
-	*
-	* @example
-	* ```ts
-	* new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
-	* new URLPath('/pet/{petId}').isURL                       // false
-	* ```
-	*/
-	get isURL() {
-		try {
-			return !!new URL(this.path).href;
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
-	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
-	*/
-	get template() {
-		return this.toTemplateString();
-	}
-	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').object
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	* ```
-	*/
-	get object() {
-		return this.toObject();
-	}
-	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+	* Detection keys off the global `Bun` object rather than `process.versions`,
+	* because Bun polyfills `process.versions.node` for Node compatibility and would
+	* otherwise look like Node.
 	*
 	* @example
 	* ```ts
-	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
-	* new URLPath('/pet').params         // undefined
+	* if (runtime.isBun) {
+	*   await Bun.write(path, data)
+	* }
 	* ```
 	*/
-	get params() {
-		return this.getParams();
-	}
-	#transformParam(raw) {
-		const param = isValidVarName(raw) ? raw : camelCase(raw);
-		return this.#options.casing === "camelcase" ? camelCase(param) : param;
+	get isBun() {
+		return typeof Bun !== "undefined";
 	}
 	/**
-	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+	* `true` when the current process is running under Deno.
 	*/
-	#eachParam(fn) {
-		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
-			const raw = match[1];
-			fn(raw, this.#transformParam(raw));
-		}
-	}
-	toObject({ type = "path", replacer, stringify } = {}) {
-		const object = {
-			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-			params: this.getParams()
-		};
-		if (stringify) {
-			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
-			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
-			return `{ url: '${object.url}' }`;
-		}
-		return object;
+	get isDeno() {
+		return typeof globalThis.Deno !== "undefined";
 	}
 	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	* An optional `replacer` can transform each extracted parameter name before interpolation.
+	* `true` when the current process is running under Node.
 	*
-	* @example
-	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
+	* Bun and Deno are excluded first so a polyfilled `process` does not register as Node.
 	*/
-	toTemplateString({ prefix = "", replacer } = {}) {
-		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = this.#transformParam(part);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("")}\``;
+	get isNode() {
+		return !this.isBun && !this.isDeno && typeof process !== "undefined" && process.versions?.node != null;
 	}
 	/**
-	* Extracts all `{param}` segments from the path and returns them as a key-value map.
-	* An optional `replacer` transforms each parameter name in both key and value positions.
-	* Returns `undefined` when no path parameters are found.
+	* Name of the runtime executing the current process.
 	*
 	* @example
 	* ```ts
-	* new URLPath('/pet/{petId}/tag/{tagId}').getParams()
-	* // { petId: 'petId', tagId: 'tagId' }
+	* runtime.name // 'bun' when run with `bun kubb`, 'node' otherwise
 	* ```
 	*/
-	getParams(replacer) {
-		const params = {};
-		this.#eachParam((_raw, param) => {
-			const key = replacer ? replacer(param) : param;
-			params[key] = key;
-		});
-		return Object.keys(params).length > 0 ? params : void 0;
+	get name() {
+		if (this.isBun) return "bun";
+		if (this.isDeno) return "deno";
+		return "node";
 	}
-	/** Converts the OpenAPI path to Express-style colon syntax.
+	/**
+	* Version of the active runtime, or an empty string when it cannot be read.
 	*
 	* @example
 	* ```ts
-	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+	* runtime.version // '1.3.11' under Bun, '22.22.2' under Node
 	* ```
 	*/
-	toURLPath() {
-		return this.path.replace(/\{([^}]+)\}/g, ":$1");
+	get version() {
+		if (this.isBun) return process.versions.bun ?? "";
+		if (this.isDeno) return globalThis.Deno?.version?.deno ?? "";
+		return process.versions?.node ?? "";
 	}
 };
+/**
+* Shared {@link Runtime} instance describing the JavaScript runtime executing the current process.
+*/
+const runtime = new Runtime();
 //#endregion
-//#region src/guards.ts
+//#region ../../internals/utils/src/fs.ts
 /**
-* Returns `true` when `doc` is a Swagger 2.0 document (no `openapi` key).
+* Resolves to `true` when the file or directory at `path` exists.
+* Uses `Bun.file().exists()` when running under Bun, `fs.access` otherwise.
 *
 * @example
 * ```ts
-* if (isOpenApiV2Document(doc)) {
-*   // doc is OpenAPIV2.Document
+* if (await exists('./kubb.config.ts')) {
+*   const content = await read('./kubb.config.ts')
 * }
 * ```
 */
-function isOpenApiV2Document(doc) {
-	return !!doc && isPlainObject(doc) && !("openapi" in doc);
+async function exists(path) {
+	if (runtime.isBun) return Bun.file(path).exists();
+	return access(path).then(() => true, () => false);
+}
+/**
+* Reads the file at `path` as a UTF-8 string.
+* Uses `Bun.file().text()` when running under Bun, `fs.readFile` otherwise.
+*
+* @example
+* ```ts
+* const source = await read('./src/Pet.ts')
+* ```
+*/
+async function read(path) {
+	if (runtime.isBun) return Bun.file(path).text();
+	return readFile(path, { encoding: "utf8" });
+}
+//#endregion
+//#region src/bundler.ts
+const urlRegExp = /^https?:\/+/i;
+async function readSource(sourcePath) {
+	if (urlRegExp.test(sourcePath)) {
+		const url = new URL(sourcePath);
+		const response = await fetch(url);
+		if (!response.ok) throw new Error(`Cannot fetch the OAS document at ${url.href} (HTTP ${response.status})`);
+		return response.text();
+	}
+	return read(sourcePath);
+}
+async function resolveSource(sourcePath) {
+	const data = await readSource(sourcePath);
+	if (sourcePath.toLowerCase().endsWith(".md")) return data;
+	return parse(data);
+}
+/**
+* Bundles a multi-file OpenAPI document into a single document via `api-ref-bundler`.
+*
+* External file schemas are hoisted into named `components.schemas` entries, so a property
+* pointing at `./schemas/User.yaml` ends up referencing `#/components/schemas/User`. Generators
+* can then emit a named type with an import instead of inlining the shape. Sources are read with
+* the Bun-aware `read` util for local YAML and JSON files, and with `fetch` for HTTP(S) URLs.
+*
+* @example Local file
+* `const document = await bundleDocument('./openapi.yaml')`
+*
+* @example Remote URL
+* `const document = await bundleDocument('https://example.com/openapi.yaml')`
+*/
+async function bundleDocument(pathOrUrl) {
+	const cache = /* @__PURE__ */ new Map();
+	const resolver = (sourcePath) => {
+		const key = urlRegExp.test(sourcePath) ? new URL(sourcePath).href : sourcePath;
+		const cached = cache.get(key);
+		if (cached) return cached;
+		const result = resolveSource(sourcePath);
+		cache.set(key, result);
+		return result;
+	};
+	await resolver(pathOrUrl);
+	return await bundle(pathOrUrl, resolver);
+}
+//#endregion
+//#region src/factory.ts
+/**
+* Loads and bundles an OpenAPI document, returning the raw `Document`.
+*
+* A string is a file path or URL: it is bundled via `api-ref-bundler`, hoisting external file
+* schemas into named `components.schemas` entries so generators can emit named types and imports.
+* An object is treated as an already-parsed document. Swagger 2.0 and OpenAPI 3.0 documents are
+* up-converted to OpenAPI 3.1 via `@scalar/openapi-upgrader`.
+*
+* @example
+* ```ts
+* const document = await parseDocument('./openapi.yaml')
+* const document = await parseDocument(rawDocumentObject)
+* ```
+*/
+async function parseDocument(pathOrApi) {
+	if (typeof pathOrApi === "string") return parseDocument(await bundleDocument(pathOrApi));
+	return upgrade(pathOrApi, "3.1");
+}
+/**
+* Creates a `Document` from an `AdapterSource`.
+*
+* - `{ type: 'path' }` resolves and bundles a local file path or remote URL.
+* - `{ type: 'data' }` parses an inline string (YAML/JSON) or raw object.
+*
+* @example
+* ```ts
+* const document = await parseFromConfig({ type: 'path', path: './openapi.yaml' })
+* const document = await parseFromConfig({ type: 'data', data: '{"openapi":"3.0.0",...}' })
+* ```
+*/
+async function parseFromConfig(source) {
+	if (source.type === "data") return parseDocument(typeof source.data === "string" ? parse(source.data) : structuredClone(source.data));
+	if (URL.canParse(source.path)) return parseDocument(source.path);
+	const resolved = path.resolve(path.dirname(source.path), source.path);
+	await assertInputExists(resolved);
+	return parseDocument(resolved);
+}
+/**
+* Throws a coded `KUBB_INPUT_NOT_FOUND` diagnostic when a local input path does not exist.
+* URLs are skipped, and a malformed but readable file is left for `parseDocument` to surface
+* its parse error instead.
+*/
+async function assertInputExists(input) {
+	if (URL.canParse(input)) return;
+	if (!await exists(input)) throw new Diagnostics.Error({
+		code: Diagnostics.code.inputNotFound,
+		severity: "error",
+		message: `Cannot read the file set in \`input.path\` (or via \`kubb generate PATH\`): ${input}`,
+		help: "Check that the path exists and is readable, then set it in `input.path` or pass it as `kubb generate PATH`.",
+		location: { kind: "config" }
+	});
+}
+/**
+* Validates an OpenAPI document using `@readme/openapi-parser` with colorized error output.
+*
+* @example
+* ```ts
+* await validateDocument(document)
+* ```
+*/
+async function validateDocument(document, { throwOnError = false } = {}) {
+	try {
+		const result = await validate(structuredClone(document), { validate: { errors: { colorize: true } } });
+		if (!result.valid) throw new Error(compileErrors(result));
+	} catch (error) {
+		if (throwOnError) throw error;
+	}
 }
+//#endregion
+//#region src/guards.ts
 /**
 * Returns `true` when a schema should be treated as nullable.
 *
@@ -615,151 +432,369 @@ function isDiscriminator(obj) {
 	return !!obj && !!record["discriminator"] && typeof record["discriminator"] !== "string";
 }
 //#endregion
-//#region src/factory.ts
+//#region src/refs.ts
+const _refCache = /* @__PURE__ */ new WeakMap();
 /**
-* Loads and dereferences an OpenAPI document, returning the raw `Document`.
+* Resolves a local JSON pointer reference from a document.
 *
-* Accepts a file path string or an already-parsed document object. File paths are bundled via
-* Redocly to resolve external `$ref`s. Swagger 2.0 documents are automatically up-converted
-* to OpenAPI 3.0 via `swagger2openapi`.
+* Accepts `#/...` refs. Returns `null` for an empty or non-local ref. When the pointer cannot be
+* resolved, reports a `refNotFound` diagnostic into the active build and returns `null`. Outside a
+* build there is no sink to collect it, so it throws instead.
 *
 * @example
 * ```ts
-* const document = await parseDocument('./openapi.yaml')
-* const document = await parse(rawDocumentObject, { canBundle: false })
+* resolveRef<SchemaObject>(document, '#/components/schemas/Pet')
 * ```
 */
-async function parseDocument(pathOrApi, { canBundle = true, enablePaths = true } = {}) {
-	if (typeof pathOrApi === "string" && canBundle) return parseDocument((await bundle({
-		ref: pathOrApi,
-		config: await loadConfig(),
-		base: pathOrApi
-	})).bundle.parsed, {
-		canBundle,
-		enablePaths
-	});
-	const document = await new OASNormalize(pathOrApi, {
-		enablePaths,
-		colorizeErrors: true
-	}).load();
-	if (isOpenApiV2Document(document)) {
-		const { openapi } = await swagger2openapi.convertObj(document, { anchors: true });
-		return openapi;
+function resolveRef(document, $ref) {
+	const origRef = $ref;
+	$ref = $ref.trim();
+	if ($ref === "") return null;
+	if (!$ref.startsWith("#")) return null;
+	$ref = globalThis.decodeURIComponent($ref.substring(1));
+	let docCache = _refCache.get(document);
+	if (!docCache) {
+		docCache = /* @__PURE__ */ new Map();
+		_refCache.set(document, docCache);
 	}
-	return document;
+	if (docCache.has($ref)) return docCache.get($ref);
+	const current = $ref.split("/").filter(Boolean).reduce((obj, key) => obj?.[key], document);
+	if (!current) {
+		const diagnostic = {
+			code: Diagnostics.code.refNotFound,
+			severity: "error",
+			message: `Could not find a definition for ${origRef}.`,
+			help: "Add the schema under `components.schemas`, or fix the `$ref`. Run `kubb validate` to check the spec.",
+			location: {
+				kind: "schema",
+				pointer: origRef,
+				ref: origRef
+			}
+		};
+		if (!Diagnostics.report(diagnostic)) throw new Diagnostics.Error(diagnostic);
+		return null;
+	}
+	docCache.set($ref, current);
+	return current;
 }
 /**
-* Deep-merges multiple OpenAPI documents into a single `Document`.
+* Resolves a `$ref` object while preserving the original `$ref` field on the result.
 *
-* Each document is parsed independently then recursively merged via `mergeDeep` from `@internals/utils`.
-* Throws when the input array is empty.
+* Useful for parser flows that need both dereferenced fields and pointer
+* identity (for naming/import purposes). Non-reference values are returned as-is.
 *
 * @example
 * ```ts
-* const document = await mergeDocuments(['./pets.yaml', './orders.yaml'])
+* dereferenceWithRef(document, { $ref: '#/components/schemas/Pet' })
+* // { $ref: '#/components/schemas/Pet', type: 'object', properties: { ... } }
 * ```
 */
-async function mergeDocuments(pathOrApi) {
-	const documents = [];
-	for (const p of pathOrApi) documents.push(await parseDocument(p, {
-		enablePaths: false,
-		canBundle: false
-	}));
-	if (documents.length === 0) throw new Error("No OAS documents provided for merging.");
-	const seed = {
-		openapi: MERGE_OPENAPI_VERSION,
-		info: {
-			title: MERGE_DEFAULT_TITLE,
-			version: MERGE_DEFAULT_VERSION
-		},
-		paths: {},
-		components: { schemas: {} }
+function dereferenceWithRef(document, schema) {
+	if (isReference(schema)) return {
+		...schema,
+		...resolveRef(document, schema.$ref),
+		$ref: schema.$ref
 	};
-	return parseDocument(documents.reduce((acc, current) => mergeDeep(acc, current), seed));
+	return schema;
 }
+//#endregion
+//#region src/dialect.ts
 /**
-* Creates a `Document` from an `AdapterSource`.
+* The OpenAPI / Swagger dialect, the default used by `@kubb/adapter-oas`.
+*
+* Implements the spec-agnostic {@link ast.SchemaDialect} contract: it isolates the
+* decisions that differ between specs (nullability, `$ref`, discriminator, binary,
+* ref resolution) so the converter pipeline and dispatch rules stay shared. A
+* future adapter (e.g. AsyncAPI) ships its own dialect, `type: ['null', …]`
+* nullability, no discriminator object, binary via `contentEncoding` and reuses
+* the rest unchanged.
 *
-* Handles all three source types:
-* - `{ type: 'path' }` — resolves and bundles a local file path or remote URL.
-* - `{ type: 'paths' }` — merges multiple file paths into a single document.
-* - `{ type: 'data' }` — parses an inline string (YAML/JSON) or raw object.
+* Formats (`uuid`, `email`, dates, …) are intentionally NOT here: they are shared
+* JSON Schema vocabulary, so the converters keep that common case.
 *
 * @example
 * ```ts
-* const document = await parseFromConfig({ type: 'path', path: './openapi.yaml' })
-* const document = await parseFromConfig({ type: 'data', data: '{"openapi":"3.0.0",...}' })
+* const parser = createSchemaParser(context)             // uses oasDialect
+* const parser = createSchemaParser(context, oasDialect) // explicit
 * ```
 */
-function parseFromConfig(source) {
-	if (source.type === "data") {
-		if (typeof source.data === "object") return parseDocument(structuredClone(source.data));
-		return parseDocument(source.data, { canBundle: false });
+const oasDialect = ast.defineDialect({
+	name: "oas",
+	schema: {
+		isNullable,
+		isReference,
+		isDiscriminator,
+		isBinary: (schema) => schema.type === "string" && schema.contentMediaType === "application/octet-stream",
+		resolveRef
 	}
-	if (source.type === "paths") return mergeDocuments(source.paths);
-	if (new URLPath(source.path).isURL) return parseDocument(source.path);
-	return parseDocument(path.resolve(path.dirname(source.path), source.path));
+});
+//#endregion
+//#region src/discriminator.ts
+/**
+* Maps each child schema name to its discriminator patch data by scanning the given
+* top-level AST schema nodes for union schemas that carry a `discriminatorPropertyName`.
+*
+* The streaming path calls this on a small pre-parsed subset of schemas (only the
+* discriminator parents) rather than on all schemas at once.
+*/
+function buildDiscriminatorChildMap(schemas) {
+	const childMap = /* @__PURE__ */ new Map();
+	for (const schema of schemas) {
+		let unionNode = ast.narrowSchema(schema, "union");
+		if (!unionNode) {
+			const intersectionMembers = ast.narrowSchema(schema, "intersection")?.members;
+			if (intersectionMembers) for (const m of intersectionMembers) {
+				const u = ast.narrowSchema(m, "union");
+				if (u) {
+					unionNode = u;
+					break;
+				}
+			}
+		}
+		if (!unionNode?.discriminatorPropertyName || !unionNode.members) continue;
+		const { discriminatorPropertyName, members } = unionNode;
+		for (const member of members) {
+			const intersectionNode = ast.narrowSchema(member, "intersection");
+			if (!intersectionNode?.members) continue;
+			let refNode = null;
+			let objNode = null;
+			for (const m of intersectionNode.members) {
+				refNode ??= ast.narrowSchema(m, "ref");
+				objNode ??= ast.narrowSchema(m, "object");
+			}
+			if (!refNode?.name || !objNode) continue;
+			const prop = objNode.properties.find((p) => p.name === discriminatorPropertyName);
+			const enumNode = prop ? ast.narrowSchema(prop.schema, "enum") : null;
+			if (!enumNode?.enumValues?.length) continue;
+			const enumValues = enumNode.enumValues.filter((v) => v !== null);
+			if (!enumValues.length) continue;
+			const existing = childMap.get(refNode.name);
+			if (!existing) {
+				childMap.set(refNode.name, {
+					propertyName: discriminatorPropertyName,
+					enumValues: [...enumValues]
+				});
+				continue;
+			}
+			existing.enumValues.push(...enumValues);
+		}
+	}
+	return childMap;
 }
 /**
-* Validates an OpenAPI document using `oas-normalize` with colorized error output.
+* Patches a single top-level `SchemaNode` with its discriminator entry (adds or replaces
+* the discriminant property). Used by the streaming path to apply patches inline per yield
+* without buffering all schemas.
+*/
+function patchDiscriminatorNode(node, entry) {
+	const objectNode = ast.narrowSchema(node, "object");
+	if (!objectNode) return node;
+	const { propertyName, enumValues } = entry;
+	const enumSchema = ast.factory.createSchema({
+		type: "enum",
+		enumValues
+	});
+	const newProp = ast.factory.createProperty({
+		name: propertyName,
+		required: true,
+		schema: enumSchema
+	});
+	const existingIdx = objectNode.properties.findIndex((p) => p.name === propertyName);
+	const newProperties = existingIdx >= 0 ? objectNode.properties.map((p, i) => i === existingIdx ? newProp : p) : [...objectNode.properties, newProp];
+	return {
+		...objectNode,
+		properties: newProperties
+	};
+}
+/**
+* Creates a single-property object schema used as a discriminator literal.
 *
 * @example
 * ```ts
-* await validateDocument(document)
+* createDiscriminantNode({ propertyName: 'type', value: 'dog' })
+* // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
 * ```
 */
-async function validateDocument(document, { throwOnError = false } = {}) {
-	try {
-		await new OASNormalize(document, {
-			enablePaths: true,
-			colorizeErrors: true
-		}).validate({ parser: { validate: { errors: { colorize: true } } } });
-	} catch (error) {
-		if (throwOnError) throw error;
-	}
+function createDiscriminantNode({ propertyName, value }) {
+	return ast.factory.createSchema({
+		type: "object",
+		primitive: "object",
+		properties: [ast.factory.createProperty({
+			name: propertyName,
+			schema: ast.factory.createSchema({
+				type: "enum",
+				primitive: "string",
+				enumValues: [value]
+			}),
+			required: true
+		})]
+	});
+}
+/**
+* Returns the discriminator key whose mapping value matches `ref`, or `null` when there is no match.
+*
+* @example
+* ```ts
+* findDiscriminator({ dog: '#/components/schemas/Dog' }, '#/components/schemas/Dog') // 'dog'
+* ```
+*/
+function findDiscriminator(mapping, ref) {
+	if (!mapping || !ref) return null;
+	return Object.entries(mapping).find(([, value]) => value === ref)?.[0] ?? null;
 }
 //#endregion
-//#region src/refs.ts
+//#region src/mime.ts
 /**
-* Resolves a local JSON pointer reference from a document.
+* MIME type fragments that mark a media type as JSON-like.
 *
-* Accepts `#/...` refs. Returns `null` for empty or non-local refs.
-* Throws when the pointer cannot be resolved.
+* A content type is JSON when it contains any of these substrings. The `+json` entry catches
+* structured-syntax suffixes such as `application/vnd.api+json`.
+*/
+const jsonMimeFragments = [
+	"application/json",
+	"application/x-json",
+	"text/json",
+	"text/x-json",
+	"+json"
+];
+/**
+* Returns `true` when a media type string is JSON-like.
 *
 * @example
 * ```ts
-* resolveRef<SchemaObject>(document, '#/components/schemas/Pet') // SchemaObject | null
+* isJsonMimeType('application/json')         // true
+* isJsonMimeType('application/vnd.api+json') // true
+* isJsonMimeType('multipart/form-data')      // false
 * ```
 */
-function resolveRef(document, $ref) {
-	const origRef = $ref;
-	$ref = $ref.trim();
-	if ($ref === "") return null;
-	if ($ref.startsWith("#")) $ref = globalThis.decodeURIComponent($ref.substring(1));
-	else return null;
-	const current = $ref.split("/").filter(Boolean).reduce((obj, key) => obj?.[key], document);
-	if (!current) throw new Error(`Could not find a definition for ${origRef}.`);
-	return current;
+function isJsonMimeType(mimeType) {
+	return jsonMimeFragments.some((fragment) => mimeType.includes(fragment));
+}
+//#endregion
+//#region src/operation.ts
+/**
+* Slugifies a path for the `operationId` fallback: non-alphanumerics collapse to single dashes,
+* with no leading or trailing dash.
+*/
+function slugify(value) {
+	return value.replace(/[^a-zA-Z0-9]/g, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "");
+}
+/**
+* Returns the operation's `operationId`, falling back to `<method>_<slugified-path>` when absent.
+*/
+function getOperationId({ path, method, schema }) {
+	const { operationId } = schema;
+	if (typeof operationId === "string" && operationId.length > 0) return operationId;
+	return `${method}_${slugify(path).toLowerCase()}`;
+}
+/**
+* Returns the declared response status codes, skipping `x-` extensions and non-object entries.
+*/
+function getResponseStatusCodes({ schema }) {
+	const responses = schema.responses;
+	if (!responses || isReference(responses)) return [];
+	return Object.keys(responses).filter((key) => !key.startsWith("x-") && !!responses[key] && typeof responses[key] === "object");
+}
+/**
+* Returns the response object for a status code, resolving a `$ref` in place. `false` when absent.
+*/
+function getResponseByStatusCode({ document, operation, statusCode }) {
+	const responses = operation.schema.responses;
+	if (!responses || isReference(responses)) return false;
+	const response = responses[statusCode];
+	if (!response) return false;
+	if (isReference(response)) {
+		const resolved = resolveRef(document, response.$ref);
+		responses[statusCode] = resolved;
+		if (!resolved || isReference(resolved)) return false;
+		return resolved;
+	}
+	return response;
+}
+/**
+* Resolves the request body (dereferencing a `$ref` in place) and returns its content map, or
+* `undefined` when the operation has no request body.
+*/
+function getRequestBodyContent({ document, operation }) {
+	const { schema } = operation;
+	let requestBody = schema.requestBody;
+	if (!requestBody) return;
+	if (isReference(requestBody)) {
+		const resolved = resolveRef(document, requestBody.$ref);
+		schema.requestBody = resolved;
+		if (!resolved || isReference(resolved)) return;
+		requestBody = resolved;
+	}
+	return requestBody.content;
+}
+/**
+* Returns the request body media type. With `mediaType` set, returns that entry or `false`.
+* Otherwise picks the first JSON-like media type, then the first declared one, as a
+* `[mediaType, object]` tuple.
+*/
+function getRequestContent({ document, operation, mediaType }) {
+	const content = getRequestBodyContent({
+		document,
+		operation
+	});
+	if (!content) return false;
+	if (mediaType) return mediaType in content ? content[mediaType] : false;
+	const mediaTypes = Object.keys(content);
+	const available = mediaTypes.find((mt) => isJsonMimeType(mt)) ?? mediaTypes[0];
+	return available ? [available, content[available]] : false;
+}
+/**
+* Returns the primary request content type. Prefers a JSON-like media type (the last one wins
+* when several are declared), then the first declared one, defaulting to `'application/json'`.
+*/
+function getRequestContentType({ document, operation }) {
+	const content = getRequestBodyContent({
+		document,
+		operation
+	});
+	const mediaTypes = content ? Object.keys(content) : [];
+	let result = mediaTypes[0] ?? "application/json";
+	for (const mt of mediaTypes) if (isJsonMimeType(mt)) result = mt;
+	return result;
 }
 /**
-* Resolves a `$ref` object while preserving the original `$ref` field on the result.
-*
-* Useful for parser flows that need both dereferenced fields and pointer
-* identity (for naming/import purposes). Non-reference values are returned as-is.
+* Builds an `Operation` for every supported HTTP method on every path, in document order.
+* `x-` path keys and unresolvable path-item `$ref`s are skipped.
 *
 * @example
 * ```ts
-* dereferenceWithRef(document, { $ref: '#/components/schemas/Pet' })
-* // { $ref: '#/components/schemas/Pet', type: 'object', properties: { ... } }
+* for (const operation of getOperations(document)) {
+*   parseOperation(options, operation)
+* }
 * ```
 */
-function dereferenceWithRef(document, schema) {
-	if (isReference(schema)) return {
-		...schema,
-		...resolveRef(document, schema.$ref),
-		$ref: schema.$ref
-	};
-	return schema;
+function getOperations(document) {
+	const operations = [];
+	const paths = document.paths;
+	if (!paths) return operations;
+	for (const path of Object.keys(paths)) {
+		if (path.startsWith("x-")) continue;
+		let pathItem = paths[path];
+		if (!pathItem) continue;
+		if (isReference(pathItem)) {
+			const resolved = resolveRef(document, pathItem.$ref);
+			paths[path] = resolved;
+			if (!resolved || isReference(resolved)) continue;
+			pathItem = resolved;
+		}
+		const item = pathItem;
+		for (const method of Object.keys(item)) {
+			if (!SUPPORTED_METHODS.has(method)) continue;
+			const schema = item[method];
+			if (!schema || typeof schema !== "object") continue;
+			operations.push({
+				path,
+				method,
+				schema
+			});
+		}
+	}
+	return operations;
 }
 //#endregion
 //#region src/resolvers.ts
@@ -783,7 +818,16 @@ function resolveServerUrl(server, overrides) {
 	for (const [key, variable] of Object.entries(server.variables)) {
 		const value = overrides?.[key] ?? (variable.default != null ? String(variable.default) : void 0);
 		if (value === void 0) continue;
-		if (variable.enum?.length && !variable.enum.some((e) => String(e) === value)) throw new Error(`Invalid server variable value '${value}' for '${key}' when resolving ${server.url}. Valid values are: ${variable.enum.join(", ")}.`);
+		if (variable.enum?.length && !variable.enum.some((e) => String(e) === value)) throw new Diagnostics.Error({
+			code: Diagnostics.code.invalidServerVariable,
+			severity: "error",
+			message: `Invalid server variable value '${value}' for '${key}' when resolving ${server.url}. Valid values are: ${variable.enum.join(", ")}.`,
+			help: `Use one of the allowed enum values, or drop the enum on the '${key}' server variable.`,
+			location: {
+				kind: "document",
+				pointer: "#/servers"
+			}
+		});
 		url = url.replaceAll(`{${key}}`, value);
 	}
 	return url;
@@ -796,6 +840,15 @@ function getSchemaType(format) {
 	return formatMap[format] ?? null;
 }
 /**
+* Whether the parser maps `format` to a dedicated type. True for any `formatMap` entry, plus the
+* `specialCasedFormats` that `convertFormat` handles directly. False means the format falls back to
+* the base type, which is what `KUBB_UNSUPPORTED_FORMAT` flags. Reading both sources keeps the
+* diagnostic in step with the parser as `formatMap` grows.
+*/
+function isHandledFormat(format) {
+	return getSchemaType(format) !== null || specialCasedFormats.has(format);
+}
+/**
 * Converts an OAS primitive type string to its `PrimitiveSchemaType` equivalent.
 * Numeric types (`number`, `integer`, `bigint`) pass through unchanged. `boolean` maps to `'boolean'`. Everything else becomes `'string'`.
 */
@@ -805,15 +858,9 @@ function getPrimitiveType(type) {
 	return "string";
 }
 /**
-* Narrows a content-type string to the `MediaType` union Kubb recognizes, or returns `null`.
-*/
-function getMediaType(contentType) {
-	return Object.values(ast.mediaTypes).includes(contentType) ? contentType : null;
-}
-/**
 * Returns all parameters for an operation, merging path-level and operation-level entries.
 * Operation-level parameters override path-level ones with the same `in:name` key.
-* `$ref` parameters resolve via `dereferenceWithRef` for backward compatibility.
+* Each `$ref` parameter is dereferenced via `dereferenceWithRef` before merging.
 *
 * @example
 * ```ts
@@ -842,7 +889,7 @@ function getResponseBody(responseBody, contentType) {
 	}
 	let availableContentType;
 	const contentTypes = Object.keys(body.content);
-	for (const mt of contentTypes) if (matchesMimeType.json(mt)) {
+	for (const mt of contentTypes) if (isJsonMimeType(mt)) {
 		availableContentType = mt;
 		break;
 	}
@@ -865,15 +912,21 @@ function getResponseBody(responseBody, contentType) {
 * getResponseSchema(document, operation, '4XX')       // {}
 * ```
 */
-function getResponseSchema(document, operation, statusCode, options = {}) {
-	if (operation.schema.responses) {
-		const responses = operation.schema.responses;
-		for (const key in responses) {
-			const schema = responses[key];
-			if (schema && isReference(schema)) responses[key] = resolveRef(document, schema.$ref);
-		}
+function resolveResponseRefs(document, operation) {
+	const responses = operation.schema.responses;
+	if (!responses) return;
+	for (const key in responses) {
+		const schema = responses[key];
+		if (schema && isReference(schema)) responses[key] = resolveRef(document, schema.$ref);
 	}
-	const responseBody = getResponseBody(operation.getResponseByStatusCode(statusCode), options.contentType);
+}
+function getResponseSchema(document, operation, statusCode, options = {}) {
+	resolveResponseRefs(document, operation);
+	const responseBody = getResponseBody(getResponseByStatusCode({
+		document,
+		operation,
+		statusCode
+	}), options.contentType);
 	if (responseBody === false) return {};
 	const schema = Array.isArray(responseBody) ? responseBody[1].schema : responseBody.schema;
 	if (!schema) return {};
@@ -889,16 +942,25 @@ function getResponseSchema(document, operation, statusCode, options = {}) {
 */
 function getRequestSchema(document, operation, options = {}) {
 	if (operation.schema.requestBody) operation.schema.requestBody = dereferenceWithRef(document, operation.schema.requestBody);
-	const requestBody = operation.getRequestBody(options.contentType);
+	const requestBody = getRequestContent({
+		document,
+		operation,
+		mediaType: options.contentType
+	});
 	if (requestBody === false) return null;
+	const mediaType = Array.isArray(requestBody) ? requestBody[0] : options.contentType;
 	const schema = Array.isArray(requestBody) ? requestBody[1].schema : requestBody.schema;
+	if (mediaType === "application/octet-stream" && (!schema || Object.keys(schema).length === 0)) return {
+		type: "string",
+		contentMediaType: "application/octet-stream"
+	};
 	if (!schema) return null;
 	return dereferenceWithRef(document, schema);
 }
 /**
 * Flattens a keyword-only `allOf` into its parent schema.
 *
-* Only flattens when every member is a plain fragment — no `$ref` and no structural keywords
+* Only flattens when every member is a plain fragment, with no `$ref` and no structural keywords
 * (see `structuralKeys`). Outer schema values take precedence over fragment values.
 * Returns `null` for a `null` input, and the original schema unchanged when flattening is unsafe.
 *
@@ -906,9 +968,12 @@ function getRequestSchema(document, operation, options = {}) {
 * ```ts
 * flattenSchema({ allOf: [{ description: 'A pet' }], type: 'object', properties: {} })
 * // { type: 'object', properties: {}, description: 'A pet' }
+* ```
 *
+* @example
+* ```ts
 * flattenSchema({ allOf: [{ $ref: '#/components/schemas/Pet' }] })
-* // returned unchanged — contains a $ref
+* // returned unchanged, contains a $ref
 * ```
 */
 /**
@@ -924,7 +989,7 @@ function hasStructuralKeywords(fragment) {
 function flattenSchema(schema) {
 	if (!schema?.allOf || schema.allOf.length === 0) return schema ?? null;
 	const allOfFragments = schema.allOf;
-	if (allOfFragments.some((item) => isRef(item))) return schema;
+	if (allOfFragments.some((item) => isReference(item))) return schema;
 	if (allOfFragments.some(hasStructuralKeywords)) return schema;
 	const merged = { ...schema };
 	delete merged.allOf;
@@ -934,7 +999,7 @@ function flattenSchema(schema) {
 /**
 * Extracts the inline schema from a media-type `content` map.
 *
-* Prefers `preferredContentType` when given; otherwise uses the first key in the map.
+* Prefers `preferredContentType` when given, otherwise uses the first key in the map.
 * Returns `null` when `content` is absent, the schema is missing, or the schema is a `$ref`.
 *
 * @example
@@ -953,21 +1018,22 @@ function extractSchemaFromContent(content, preferredContentType) {
 /**
 * Walks a schema tree and collects the names of all `#/components/schemas/<name>` `$ref`s.
 */
-function collectRefs(schema, refs = /* @__PURE__ */ new Set()) {
+function* collectRefs(schema) {
 	if (Array.isArray(schema)) {
-		for (const item of schema) collectRefs(item, refs);
-		return refs;
+		for (const item of schema) yield* collectRefs(item);
+		return;
 	}
 	if (schema && typeof schema === "object") for (const key in schema) {
 		const value = schema[key];
-		if (key === "$ref" && typeof value === "string") {
-			if (value.startsWith("#/components/schemas/")) {
-				const name = value.slice(21);
-				if (name) refs.add(name);
-			}
-		} else collectRefs(value, refs);
+		if (!(key === "$ref" && typeof value === "string")) {
+			yield* collectRefs(value);
+			continue;
+		}
+		if (value.startsWith("#/components/schemas/")) {
+			const name = value.slice(21);
+			if (name) yield name;
+		}
 	}
-	return refs;
 }
 /**
 * Returns a copy of `schemas` topologically sorted by `$ref` dependency.
@@ -983,7 +1049,7 @@ function collectRefs(schema, refs = /* @__PURE__ */ new Set()) {
 */
 function sortSchemas(schemas) {
 	const deps = /* @__PURE__ */ new Map();
-	for (const [name, schema] of Object.entries(schemas)) deps.set(name, Array.from(collectRefs(schema)));
+	for (const [name, schema] of Object.entries(schemas)) deps.set(name, [...new Set(collectRefs(schema))]);
 	const sorted = [];
 	const visited = /* @__PURE__ */ new Set();
 	function visit(name, stack) {
@@ -1004,9 +1070,6 @@ const semanticSuffixes = {
 	responses: "Response",
 	requestBodies: "Request"
 };
-function getSemanticSuffix(source) {
-	return semanticSuffixes[source];
-}
 function resolveSchemaRef(document, schema) {
 	if (!isReference(schema)) return schema;
 	const resolved = resolveRef(document, schema.$ref);
@@ -1061,7 +1124,7 @@ function getSchemas(document, { contentType }) {
 			}
 		}
 		items.forEach((item, index) => {
-			const suffix = isSingle ? "" : hasMultipleSources ? getSemanticSuffix(item.source) : index === 0 ? "" : String(index + 1);
+			const suffix = isSingle ? "" : hasMultipleSources ? semanticSuffixes[item.source] : index === 0 ? "" : String(index + 1);
 			const uniqueName = item.originalName + suffix;
 			schemas[uniqueName] = item.schema;
 			nameMapping.set(`#/components/${item.source}/${item.originalName}`, uniqueName);
@@ -1074,7 +1137,7 @@ function getSchemas(document, { contentType }) {
 }
 /**
 * Resolves the AST type descriptor for a date/time format, honoring the `dateType` option.
-* Returns `null` when `dateType: false`, signalling the format should fall through to `string`.
+* Returns `null` when `dateType: false`, so the format falls through to `string`.
 */
 function getDateType(options, format) {
 	if (!options.dateType) return null;
@@ -1108,6 +1171,15 @@ function getDateType(options, format) {
 /**
 * Collects the shared metadata fields passed to every `createSchema` call.
 */
+/**
+* Reads schema examples as an array. OAS 3.1 uses an `examples` array, but specs (including ones
+* labeled 3.1) still use the singular OAS 3.0 `example`, which the upgrader only converts on the
+* 3.0 -> 3.1 hop. Normalize both into one array so the AST node exposes only `examples`.
+*/
+function extractExamples(schema) {
+	if (Array.isArray(schema.examples)) return schema.examples;
+	return schema.example !== void 0 ? [schema.example] : void 0;
+}
 function buildSchemaNode(schema, name, nullable, defaultValue) {
 	return {
 		name,
@@ -1118,15 +1190,16 @@ function buildSchemaNode(schema, name, nullable, defaultValue) {
 		readOnly: schema.readOnly,
 		writeOnly: schema.writeOnly,
 		default: defaultValue,
-		example: schema.example
+		examples: extractExamples(schema),
+		format: schema.format
 	};
 }
 /**
 * Returns all request body content type keys for an operation.
 *
-* The requestBody is dereferenced **in-place** when it is a `$ref` — the same mutation
-* that `getRequestSchema` already performs — so that the returned list accurately reflects
-* the available content types even for referenced bodies.
+* The requestBody is dereferenced in place when it is a `$ref` (the same mutation that
+* `getRequestSchema` already performs), so the returned list accurately reflects the
+* available content types even for referenced bodies.
 *
 * @example
 * ```ts
@@ -1140,15 +1213,38 @@ function getRequestBodyContentTypes(document, operation) {
 	if (!body) return [];
 	return body.content ? Object.keys(body.content) : [];
 }
+/**
+* Returns all response content type keys for an operation at a given status code.
+*
+* Response `$ref`s are resolved in place first (the same mutation `getResponseSchema` performs),
+* so the returned list reflects the available content types even for referenced responses.
+*
+* @example
+* ```ts
+* getResponseBodyContentTypes(document, operation, 200)
+* // ['application/json', 'application/xml']
+* ```
+*/
+function getResponseBodyContentTypes(document, operation, statusCode) {
+	resolveResponseRefs(document, operation);
+	const responseObj = getResponseByStatusCode({
+		document,
+		operation,
+		statusCode
+	});
+	if (!responseObj || typeof responseObj !== "object" || isReference(responseObj)) return [];
+	const body = responseObj;
+	return body.content ? Object.keys(body.content) : [];
+}
 //#endregion
 //#region src/parser.ts
 /**
 * Normalizes malformed `{ type: 'array', enum: [...] }` schemas by moving enum values into items.
 *
 * This pattern violates the OpenAPI spec but appears in real specs. The fix moves enum values
-* from the array to its items sub-schema, making them valid for downstream processing.
+* from the array to its items sub-schema, so they are valid for downstream processing.
 *
-* @note This is a defensive measure for robustness with non-compliant specs.
+* @note A defensive measure for non-compliant specs.
 */
 function normalizeArrayEnum(schema) {
 	const normalizedItems = {
@@ -1162,15 +1258,48 @@ function normalizeArrayEnum(schema) {
 	};
 }
 /**
+* Builds a `null` scalar node carrying the schema's documentation. Shared by the `const: null`
+* and the drf-spectacular `NullEnum` (`{ enum: [null] }`) branches, which render identically.
+*/
+function createNullSchema(schema, name, nullable) {
+	return ast.factory.createSchema({
+		type: "null",
+		primitive: "null",
+		name,
+		title: schema.title,
+		description: schema.description,
+		deprecated: schema.deprecated,
+		nullable,
+		format: schema.format
+	});
+}
+/**
+* Names the inline enums on a property's schema, and on each item when the property is a tuple, from
+* the parent and property name. Wraps `macroEnumName` at the property construction site.
+*/
+function nameEnums(node, options) {
+	const macro = macroEnumName(options);
+	const named = ast.applyMacros(node, [macro], { depth: "shallow" });
+	const tupleNode = ast.narrowSchema(named, "tuple");
+	if (tupleNode?.items) {
+		const namedItems = tupleNode.items.map((item) => ast.applyMacros(item, [macro], { depth: "shallow" }));
+		if (namedItems.some((item, i) => item !== tupleNode.items[i])) return {
+			...tupleNode,
+			items: namedItems
+		};
+	}
+	return named;
+}
+/**
 * Factory function that creates schema and operation converters for a given OpenAPI context.
 *
 * Returns closures that share mutable state (`resolvingRefs` set for cycle detection).
 * Each converter branch (`convertRef`, `convertAllOf`, etc.) mutually recursively calls `parseSchema`,
-* made possible by hoisting of function declarations.
+* which works because function declarations hoist.
 *
-* @note Not exported; called internally by `parseOas()` and `parseSchema()`.
+* @internal
 */
-function createSchemaParser(ctx) {
+function createSchemaParser(ctx, dialect = oasDialect) {
 	const document = ctx.document;
 	/**
 	* Tracks `$ref` paths that are currently being resolved to prevent infinite
@@ -1178,6 +1307,15 @@ function createSchemaParser(ctx) {
 	*/
 	const resolvingRefs = /* @__PURE__ */ new Set();
 	/**
+	* Cache of `$ref` schemas already resolved in this parser instance, keyed by ref path.
+	*
+	* Without it, a shared schema (e.g. `customer`) is re-expanded for every `$ref` that points at
+	* it. In cross-referenced specs like Stripe (~1400 schemas) that becomes exponential blowup,
+	* since one schema can be referenced from dozens of parents, each re-walking its whole subtree.
+	* Memoizing by ref path drops the work from O(2^depth) to O(N) unique schema names.
+	*/
+	const resolvedRefCache = /* @__PURE__ */ new Map();
+	/**
 	* Converts a `$ref` schema into a `RefSchemaNode`.
 	*
 	* The resolved schema is stored in `node.schema`. Usage-site sibling fields
@@ -1186,20 +1324,26 @@ function createSchemaParser(ctx) {
 	* Circular refs are detected via `resolvingRefs` and leave `schema` as `undefined`.
 	*/
 	function convertRef({ schema, name, nullable, defaultValue, rawOptions }) {
-		let resolvedSchema;
+		let resolvedSchema = null;
 		const refPath = schema.$ref;
-		if (refPath && !resolvingRefs.has(refPath)) try {
-			const referenced = resolveRef(document, refPath);
-			if (referenced) {
-				resolvingRefs.add(refPath);
-				resolvedSchema = parseSchema({ schema: referenced }, rawOptions);
-				resolvingRefs.delete(refPath);
+		if (refPath && !resolvingRefs.has(refPath)) {
+			if (!resolvedRefCache.has(refPath)) {
+				try {
+					const referenced = dialect.schema.resolveRef(document, refPath);
+					if (referenced) {
+						resolvingRefs.add(refPath);
+						resolvedSchema = parseSchema({ schema: referenced }, rawOptions);
+						resolvingRefs.delete(refPath);
+					}
+				} catch {}
+				resolvedRefCache.set(refPath, resolvedSchema);
 			}
-		} catch {}
-		return ast.createSchema({
+			resolvedSchema = resolvedRefCache.get(refPath) ?? null;
+		}
+		return ast.factory.createSchema({
 			...buildSchemaNode(schema, name, nullable, defaultValue),
 			type: "ref",
-			name: ast.extractRefName(schema.$ref),
+			name: extractRefName(schema.$ref),
 			ref: schema.$ref,
 			schema: resolvedSchema
 		});
@@ -1212,12 +1356,12 @@ function createSchemaParser(ctx) {
 			const [memberSchema] = schema.allOf;
 			const memberNode = parseSchema({
 				schema: memberSchema,
-				name: null
+				name
 			}, rawOptions);
 			const { kind: _kind, ...memberNodeProps } = memberNode;
 			const mergedNullable = nullable || memberNode.nullable || void 0;
 			const mergedDefault = schema.default === null && mergedNullable ? void 0 : schema.default ?? memberNode.default;
-			return ast.createSchema({
+			return ast.factory.createSchema({
 				...memberNodeProps,
 				name,
 				title: schema.title ?? memberNode.title,
@@ -1227,22 +1371,23 @@ function createSchemaParser(ctx) {
 				readOnly: schema.readOnly ?? memberNode.readOnly,
 				writeOnly: schema.writeOnly ?? memberNode.writeOnly,
 				default: mergedDefault,
-				example: schema.example ?? memberNode.example,
-				pattern: schema.pattern ?? ("pattern" in memberNode ? memberNode.pattern : void 0)
+				examples: extractExamples(schema) ?? memberNode.examples,
+				pattern: schema.pattern ?? ("pattern" in memberNode ? memberNode.pattern : void 0),
+				format: schema.format ?? memberNode.format
 			});
 		}
 		const filteredDiscriminantValues = [];
 		const allOfMembers = schema.allOf.filter((item) => {
-			if (!isReference(item) || !name) return true;
-			const deref = resolveRef(document, item.$ref);
-			if (!deref || !isDiscriminator(deref)) return true;
+			if (!dialect.schema.isReference(item) || !name) return true;
+			const deref = dialect.schema.resolveRef(document, item.$ref);
+			if (!deref || !dialect.schema.isDiscriminator(deref)) return true;
 			const parentUnion = deref.oneOf ?? deref.anyOf;
 			if (!parentUnion) return true;
 			const childRef = `${SCHEMA_REF_PREFIX}${name}`;
-			const inOneOf = parentUnion.some((oneOfItem) => isReference(oneOfItem) && oneOfItem.$ref === childRef);
+			const inOneOf = parentUnion.some((oneOfItem) => dialect.schema.isReference(oneOfItem) && oneOfItem.$ref === childRef);
 			const inMapping = Object.values(deref.discriminator.mapping ?? {}).some((v) => v === childRef);
 			if (inOneOf || inMapping) {
-				const discriminatorValue = ast.findDiscriminator(deref.discriminator.mapping, childRef);
+				const discriminatorValue = findDiscriminator(deref.discriminator.mapping, childRef);
 				if (discriminatorValue) filteredDiscriminantValues.push({
 					propertyName: deref.discriminator.propertyName,
 					value: discriminatorValue
@@ -1250,22 +1395,28 @@ function createSchemaParser(ctx) {
 				return false;
 			}
 			return true;
-		}).map((s) => parseSchema({ schema: s }, rawOptions));
+		}).map((s) => parseSchema({
+			schema: s,
+			name
+		}, rawOptions));
 		const syntheticStart = allOfMembers.length;
 		if (Array.isArray(schema.required) && schema.required.length) {
 			const outerKeys = schema.properties ? new Set(Object.keys(schema.properties)) : /* @__PURE__ */ new Set();
 			const missingRequired = schema.required.filter((key) => !outerKeys.has(key));
 			if (missingRequired.length) {
 				const resolvedMembers = schema.allOf.flatMap((item) => {
-					if (!isReference(item)) return [item];
-					const deref = resolveRef(document, item.$ref);
-					return deref && !isReference(deref) ? [deref] : [];
+					if (!dialect.schema.isReference(item)) return [item];
+					const deref = dialect.schema.resolveRef(document, item.$ref);
+					return deref && !dialect.schema.isReference(deref) ? [deref] : [];
 				});
 				for (const key of missingRequired) for (const resolved of resolvedMembers) if (resolved.properties?.[key]) {
-					allOfMembers.push(parseSchema({ schema: {
-						properties: { [key]: resolved.properties[key] },
-						required: [key]
-					} }, rawOptions));
+					allOfMembers.push(parseSchema({
+						schema: {
+							properties: { [key]: resolved.properties[key] },
+							required: [key]
+						},
+						name
+					}, rawOptions));
 					break;
 				}
 			}
@@ -1274,13 +1425,13 @@ function createSchemaParser(ctx) {
 			const { allOf: _allOf, ...schemaWithoutAllOf } = schema;
 			allOfMembers.push(parseSchema({ schema: schemaWithoutAllOf }, rawOptions));
 		}
-		for (const { propertyName, value } of filteredDiscriminantValues) allOfMembers.push(ast.createDiscriminantNode({
+		for (const { propertyName, value } of filteredDiscriminantValues) allOfMembers.push(createDiscriminantNode({
 			propertyName,
 			value
 		}));
-		return ast.createSchema({
+		return ast.factory.createSchema({
 			type: "intersection",
-			members: [...ast.mergeAdjacentObjects(allOfMembers.slice(0, syntheticStart)), ...ast.mergeAdjacentObjects(allOfMembers.slice(syntheticStart))],
+			members: [...mergeAdjacentObjectsLazy(allOfMembers.slice(0, syntheticStart)), ...mergeAdjacentObjectsLazy(allOfMembers.slice(syntheticStart))],
 			...buildSchemaNode(schema, name, nullable, defaultValue)
 		});
 	}
@@ -1291,79 +1442,104 @@ function createSchemaParser(ctx) {
 		function pickDiscriminatorPropertyNode(node, propertyName) {
 			const discriminatorProperty = ast.narrowSchema(node, "object")?.properties?.find((property) => property.name === propertyName);
 			if (!discriminatorProperty) return null;
-			return ast.createSchema({
+			return ast.factory.createSchema({
 				type: "object",
 				primitive: "object",
 				properties: [discriminatorProperty]
 			});
 		}
+		function resolveRefSilent($ref) {
+			if (!$ref.startsWith("#")) return null;
+			return decodeURIComponent($ref.substring(1)).split("/").filter(Boolean).reduce((obj, key) => obj?.[key], document) ?? null;
+		}
+		function implicitDiscriminantValue(member) {
+			if (!discriminator || discriminator.mapping || !dialect.schema.isReference(member)) return null;
+			const value = extractRefName(member.$ref);
+			if (!value) return null;
+			const variant = resolveRefSilent(member.$ref);
+			if (!variant) return null;
+			const propertyName = discriminator.propertyName;
+			const seen = new Set([member.$ref]);
+			function constrains(v) {
+				const prop = v.properties?.[propertyName];
+				const resolved = prop && dialect.schema.isReference(prop) ? resolveRefSilent(prop.$ref) : prop;
+				if (resolved && (Array.isArray(resolved.enum) || resolved.const !== void 0)) return true;
+				const composition = v.allOf ?? v.oneOf ?? v.anyOf;
+				if (!composition) return false;
+				return composition.some((m) => {
+					if (!dialect.schema.isReference(m)) return constrains(m);
+					if (seen.has(m.$ref)) return false;
+					seen.add(m.$ref);
+					const r = resolveRefSilent(m.$ref);
+					return r ? constrains(r) : false;
+				});
+			}
+			return constrains(variant) ? null : value;
+		}
 		const unionMembers = [...schema.oneOf ?? [], ...schema.anyOf ?? []];
 		const strategy = schema.oneOf ? "one" : "any";
 		const unionBase = {
 			...buildSchemaNode(schema, name, nullable, defaultValue),
-			discriminatorPropertyName: isDiscriminator(schema) ? schema.discriminator.propertyName : void 0,
+			discriminatorPropertyName: dialect.schema.isDiscriminator(schema) ? schema.discriminator.propertyName : void 0,
 			strategy
 		};
-		const discriminator = isDiscriminator(schema) ? schema.discriminator : void 0;
-		const sharedPropertiesNode = schema.properties ? (() => {
-			const { oneOf: _oneOf, anyOf: _anyOf, ...schemaWithoutUnion } = schema;
-			return parseSchema({
-				schema: discriminator ? Object.fromEntries(Object.entries(schemaWithoutUnion).filter(([key]) => key !== "discriminator")) : schemaWithoutUnion,
-				name
-			}, rawOptions);
-		})() : void 0;
-		if (sharedPropertiesNode || discriminator?.mapping) {
+		const discriminator = dialect.schema.isDiscriminator(schema) ? schema.discriminator : void 0;
+		const { oneOf: _o, anyOf: _a, discriminator: _d, ...memberBaseSchema } = schema;
+		const sharedPropertiesNode = schema.properties ? parseSchema({
+			schema: memberBaseSchema,
+			name
+		}, rawOptions) : void 0;
+		if (sharedPropertiesNode || discriminator) {
 			const members = unionMembers.map((s) => {
-				const ref = isReference(s) ? s.$ref : void 0;
-				const discriminatorValue = ast.findDiscriminator(discriminator?.mapping, ref);
-				const memberNode = parseSchema({ schema: s }, rawOptions);
+				const ref = dialect.schema.isReference(s) ? s.$ref : void 0;
+				const discriminatorValue = findDiscriminator(discriminator?.mapping, ref) ?? implicitDiscriminantValue(s);
+				const memberNode = parseSchema({
+					schema: s,
+					name
+				}, rawOptions);
 				if (!discriminatorValue || !discriminator) return memberNode;
-				const narrowedDiscriminatorNode = sharedPropertiesNode ? pickDiscriminatorPropertyNode(ast.setDiscriminatorEnum({
-					node: sharedPropertiesNode,
+				const narrowedDiscriminatorNode = sharedPropertiesNode ? pickDiscriminatorPropertyNode(ast.applyMacros(sharedPropertiesNode, [macroDiscriminatorEnum({
 					propertyName: discriminator.propertyName,
 					values: [discriminatorValue]
-				}), discriminator.propertyName) : void 0;
-				return ast.createSchema({
+				})], { depth: "shallow" }), discriminator.propertyName) : void 0;
+				return ast.factory.createSchema({
 					type: "intersection",
-					members: [memberNode, narrowedDiscriminatorNode ?? ast.createDiscriminantNode({
+					members: [memberNode, narrowedDiscriminatorNode ?? createDiscriminantNode({
 						propertyName: discriminator.propertyName,
 						value: discriminatorValue
 					})]
 				});
 			});
-			const unionNode = ast.createSchema({
+			const unionNode = ast.factory.createSchema({
 				type: "union",
 				...unionBase,
 				members
 			});
 			if (!sharedPropertiesNode) return unionNode;
-			return ast.createSchema({
+			return ast.factory.createSchema({
 				type: "intersection",
 				...buildSchemaNode(schema, name, nullable, defaultValue),
 				members: [unionNode, sharedPropertiesNode]
 			});
 		}
-		return ast.createSchema({
+		const unionNode = ast.factory.createSchema({
 			type: "union",
 			...unionBase,
-			members: ast.simplifyUnion(unionMembers.map((s) => parseSchema({ schema: s }, rawOptions)))
+			members: unionMembers.map((s) => parseSchema({
+				schema: s,
+				name
+			}, rawOptions))
 		});
+		return ast.applyMacros(unionNode, [macroSimplifyUnion], { depth: "shallow" });
 	}
 	/**
 	* Converts an OAS 3.1 `const` schema into a null scalar or a single-value `EnumSchemaNode`.
 	*/
 	function convertConst({ schema, name, nullable, defaultValue }) {
 		const constValue = schema.const;
-		if (constValue === null) return ast.createSchema({
-			type: "null",
-			primitive: "null",
-			name,
-			title: schema.title,
-			description: schema.description,
-			deprecated: schema.deprecated
-		});
+		if (constValue === null) return createNullSchema(schema, name);
 		const constPrimitive = getPrimitiveType(typeof constValue === "number" ? "number" : typeof constValue === "boolean" ? "boolean" : "string");
-		return ast.createSchema({
+		return ast.factory.createSchema({
 			type: "enum",
 			primitive: constPrimitive,
 			enumValues: [constValue],
@@ -1376,7 +1552,7 @@ function createSchemaParser(ctx) {
 	*/
 	function convertFormat({ schema, name, nullable, defaultValue, options }) {
 		const base = buildSchemaNode(schema, name, nullable, defaultValue);
-		if (schema.format === "int64") return ast.createSchema({
+		if (schema.format === "int64") return ast.factory.createSchema({
 			type: options.integerType === "bigint" ? "bigint" : "integer",
 			primitive: "integer",
 			...base,
@@ -1388,14 +1564,14 @@ function createSchemaParser(ctx) {
 		if (schema.format === "date-time" || schema.format === "date" || schema.format === "time") {
 			const dateType = getDateType(options, schema.format);
 			if (!dateType) return null;
-			if (dateType.type === "datetime") return ast.createSchema({
+			if (dateType.type === "datetime") return ast.factory.createSchema({
 				...base,
 				primitive: "string",
 				type: "datetime",
 				offset: dateType.offset,
 				local: dateType.local
 			});
-			return ast.createSchema({
+			return ast.factory.createSchema({
 				...base,
 				primitive: "string",
 				type: dateType.type,
@@ -1405,36 +1581,36 @@ function createSchemaParser(ctx) {
 		const specialType = getSchemaType(schema.format);
 		if (!specialType) return null;
 		const specialPrimitive = specialType === "number" || specialType === "integer" || specialType === "bigint" ? specialType : "string";
-		if (specialType === "number" || specialType === "integer" || specialType === "bigint") return ast.createSchema({
+		if (specialType === "number" || specialType === "integer" || specialType === "bigint") return ast.factory.createSchema({
 			...base,
 			primitive: specialPrimitive,
 			type: specialType
 		});
-		if (specialType === "url") return ast.createSchema({
+		if (specialType === "url") return ast.factory.createSchema({
 			...base,
 			primitive: "string",
 			type: "url",
 			min: schema.minLength,
 			max: schema.maxLength
 		});
-		if (specialType === "ipv4") return ast.createSchema({
+		if (specialType === "ipv4") return ast.factory.createSchema({
 			...base,
 			primitive: "string",
 			type: "ipv4"
 		});
-		if (specialType === "ipv6") return ast.createSchema({
+		if (specialType === "ipv6") return ast.factory.createSchema({
 			...base,
 			primitive: "string",
 			type: "ipv6"
 		});
-		if (specialType === "uuid" || specialType === "email") return ast.createSchema({
+		if (specialType === "uuid" || specialType === "email") return ast.factory.createSchema({
 			...base,
 			primitive: "string",
 			type: specialType,
 			min: schema.minLength,
 			max: schema.maxLength
 		});
-		return ast.createSchema({
+		return ast.factory.createSchema({
 			...base,
 			primitive: specialPrimitive,
 			type: specialType
@@ -1450,6 +1626,7 @@ function createSchemaParser(ctx) {
 		}, rawOptions);
 		const nullInEnum = schema.enum.includes(null);
 		const filteredValues = nullInEnum ? schema.enum.filter((v) => v !== null) : schema.enum;
+		if (nullInEnum && filteredValues.length === 0) return createNullSchema(schema, name);
 		const enumNullable = nullable || nullInEnum || void 0;
 		const enumDefault = schema.default === null && enumNullable ? void 0 : schema.default;
 		const enumPrimitive = getPrimitiveType(type);
@@ -1464,21 +1641,25 @@ function createSchemaParser(ctx) {
 			readOnly: schema.readOnly,
 			writeOnly: schema.writeOnly,
 			default: enumDefault,
-			example: schema.example
+			examples: extractExamples(schema),
+			format: schema.format
 		};
 		const extensionKey = enumExtensionKeys.find((key) => key in schema);
-		if (extensionKey || enumPrimitive === "number" || enumPrimitive === "integer" || enumPrimitive === "boolean") {
+		const descriptionKey = enumDescriptionKeys.find((key) => key in schema);
+		if (extensionKey || descriptionKey || enumPrimitive === "number" || enumPrimitive === "integer" || enumPrimitive === "boolean") {
 			const enumPrimitiveType = enumPrimitive === "number" || enumPrimitive === "integer" ? "number" : enumPrimitive === "boolean" ? "boolean" : "string";
 			const rawEnumNames = extensionKey ? schema[extensionKey] : void 0;
+			const rawEnumDescriptions = descriptionKey ? schema[descriptionKey] : void 0;
 			const uniqueValues = [...new Set(filteredValues)];
 			const seenNames = /* @__PURE__ */ new Set();
-			return ast.createSchema({
+			return ast.factory.createSchema({
 				...enumBase,
 				primitive: enumPrimitiveType,
 				namedEnumValues: uniqueValues.map((value, index) => ({
 					name: String(rawEnumNames?.[index] ?? value),
 					value,
-					primitive: enumPrimitiveType
+					primitive: enumPrimitiveType,
+					description: rawEnumDescriptions?.[index]
 				})).filter((entry) => {
 					if (seenNames.has(entry.name)) return false;
 					seenNames.add(entry.name);
@@ -1486,7 +1667,7 @@ function createSchemaParser(ctx) {
 				})
 			});
 		}
-		return ast.createSchema({
+		return ast.factory.createSchema({
 			...enumBase,
 			enumValues: [...new Set(filteredValues)]
 		});
@@ -1498,21 +1679,16 @@ function createSchemaParser(ctx) {
 		const properties = schema.properties ? Object.entries(schema.properties).map(([propName, propSchema]) => {
 			const required = Array.isArray(schema.required) ? schema.required.includes(propName) : !!schema.required;
 			const resolvedPropSchema = propSchema;
-			const propNullable = isNullable(resolvedPropSchema);
-			const propNode = parseSchema({
+			const propNullable = dialect.schema.isNullable(resolvedPropSchema);
+			const schemaNode = nameEnums(parseSchema({
 				schema: resolvedPropSchema,
-				name: ast.childName(name, propName)
-			}, rawOptions);
-			let schemaNode = ast.setEnumName(propNode, name, propName, options.enumSuffix);
-			const tupleNode = ast.narrowSchema(schemaNode, "tuple");
-			if (tupleNode?.items) {
-				const namedItems = tupleNode.items.map((item) => ast.setEnumName(item, name, propName, options.enumSuffix));
-				if (namedItems.some((item, i) => item !== tupleNode.items[i])) schemaNode = {
-					...tupleNode,
-					items: namedItems
-				};
-			}
-			return ast.createProperty({
+				name: childName(name, propName)
+			}, rawOptions), {
+				parentName: name,
+				propName,
+				enumSuffix: options.enumSuffix
+			});
+			return ast.factory.createProperty({
 				name: propName,
 				schema: {
 					...schemaNode,
@@ -1522,14 +1698,15 @@ function createSchemaParser(ctx) {
 			});
 		}) : [];
 		const additionalProperties = schema.additionalProperties;
-		let additionalPropertiesNode;
-		if (additionalProperties === true) additionalPropertiesNode = true;
-		else if (additionalProperties && Object.keys(additionalProperties).length > 0) additionalPropertiesNode = parseSchema({ schema: additionalProperties }, rawOptions);
-		else if (additionalProperties === false) additionalPropertiesNode = false;
-		else if (additionalProperties) additionalPropertiesNode = ast.createSchema({ type: typeOptionMap.get(options.unknownType) });
+		const additionalPropertiesNode = (() => {
+			if (additionalProperties === true) return true;
+			if (additionalProperties === false) return false;
+			if (additionalProperties && Object.keys(additionalProperties).length > 0) return parseSchema({ schema: additionalProperties }, rawOptions);
+			if (additionalProperties) return ast.factory.createSchema({ type: options.unknownType });
+		})();
 		const rawPatternProperties = "patternProperties" in schema ? schema.patternProperties : void 0;
-		const patternProperties = rawPatternProperties ? Object.fromEntries(Object.entries(rawPatternProperties).map(([pattern, patternSchema]) => [pattern, patternSchema === true || typeof patternSchema === "object" && Object.keys(patternSchema).length === 0 ? ast.createSchema({ type: typeOptionMap.get(options.unknownType) }) : parseSchema({ schema: patternSchema }, rawOptions)])) : void 0;
-		const objectNode = ast.createSchema({
+		const patternProperties = rawPatternProperties ? Object.fromEntries(Object.entries(rawPatternProperties).map(([pattern, patternSchema]) => [pattern, patternSchema === true || typeof patternSchema === "object" && Object.keys(patternSchema).length === 0 ? ast.factory.createSchema({ type: options.unknownType }) : parseSchema({ schema: patternSchema }, rawOptions)])) : void 0;
+		const objectNode = ast.factory.createSchema({
 			type: "object",
 			primitive: "object",
 			properties,
@@ -1539,16 +1716,15 @@ function createSchemaParser(ctx) {
 			maxProperties: schema.maxProperties,
 			...buildSchemaNode(schema, name, nullable, defaultValue)
 		});
-		if (isDiscriminator(schema) && schema.discriminator.mapping) {
+		if (dialect.schema.isDiscriminator(schema) && schema.discriminator.mapping) {
 			const discPropName = schema.discriminator.propertyName;
 			const values = Object.keys(schema.discriminator.mapping);
-			const enumName = name ? ast.enumPropName(name, discPropName, options.enumSuffix) : void 0;
-			return ast.setDiscriminatorEnum({
-				node: objectNode,
+			const enumName = name ? enumPropName(name, discPropName, options.enumSuffix) : void 0;
+			return ast.applyMacros(objectNode, [macroDiscriminatorEnum({
 				propertyName: discPropName,
 				values,
 				enumName
-			});
+			})], { depth: "shallow" });
 		}
 		return objectNode;
 	}
@@ -1557,8 +1733,8 @@ function createSchemaParser(ctx) {
 	*/
 	function convertTuple({ schema, name, nullable, defaultValue, rawOptions }) {
 		const tupleItems = (schema.prefixItems ?? []).map((item) => parseSchema({ schema: item }, rawOptions));
-		const rest = schema.items ? parseSchema({ schema: schema.items }, rawOptions) : ast.createSchema({ type: "any" });
-		return ast.createSchema({
+		const rest = schema.items === false ? void 0 : !schema.items || schema.items === true ? ast.factory.createSchema({ type: "any" }) : parseSchema({ schema: schema.items }, rawOptions);
+		return ast.factory.createSchema({
 			type: "tuple",
 			primitive: "array",
 			items: tupleItems,
@@ -1573,12 +1749,12 @@ function createSchemaParser(ctx) {
 	*/
 	function convertArray({ schema, name, nullable, defaultValue, rawOptions, options }) {
 		const rawItems = schema.items;
-		const itemName = rawItems?.enum?.length && name ? ast.enumPropName(void 0, name, options.enumSuffix) : void 0;
+		const itemName = rawItems?.enum?.length && name ? enumPropName(null, name, options.enumSuffix) : name;
 		const items = rawItems ? [parseSchema({
 			schema: rawItems,
 			name: itemName
 		}, rawOptions)] : [];
-		return ast.createSchema({
+		return ast.factory.createSchema({
 			type: "array",
 			primitive: "array",
 			items,
@@ -1592,7 +1768,7 @@ function createSchemaParser(ctx) {
 	* Converts a `type: 'string'` schema into a `StringSchemaNode`.
 	*/
 	function convertString({ schema, name, nullable, defaultValue }) {
-		return ast.createSchema({
+		return ast.factory.createSchema({
 			type: "string",
 			primitive: "string",
 			min: schema.minLength,
@@ -1605,7 +1781,7 @@ function createSchemaParser(ctx) {
 	* Converts a `type: 'number'` or `type: 'integer'` schema.
 	*/
 	function convertNumeric({ schema, name, nullable, defaultValue }, type) {
-		return ast.createSchema({
+		return ast.factory.createSchema({
 			type,
 			primitive: type,
 			min: schema.minimum,
@@ -1620,32 +1796,132 @@ function createSchemaParser(ctx) {
 	* Converts a `type: 'boolean'` schema.
 	*/
 	function convertBoolean({ schema, name, nullable, defaultValue }) {
-		return ast.createSchema({
+		return ast.factory.createSchema({
 			type: "boolean",
 			primitive: "boolean",
 			...buildSchemaNode(schema, name, nullable, defaultValue)
 		});
 	}
 	/**
-	* Converts an explicit `type: 'null'` schema.
+	* Converts a binary string schema (`type: 'string'`, `contentMediaType: 'application/octet-stream'`)
+	* into a `blob` node.
 	*/
-	function convertNull({ schema, name, nullable }) {
-		return ast.createSchema({
-			type: "null",
-			primitive: "null",
-			name,
-			title: schema.title,
-			description: schema.description,
-			deprecated: schema.deprecated,
-			nullable
+	function convertBlob({ schema, name, nullable, defaultValue }) {
+		return ast.factory.createSchema({
+			type: "blob",
+			primitive: "string",
+			...buildSchemaNode(schema, name, nullable, defaultValue)
+		});
+	}
+	/**
+	* Converts an OAS 3.1 multi-type array (e.g. `type: ['string', 'number']`) into a `UnionSchemaNode`.
+	*
+	* Returns `null` when only one non-`null` type remains (e.g. `['string', 'null']`), so `parseSchema`
+	* falls through and handles it as that single type with nullability already folded in.
+	*/
+	function convertMultiType({ schema, name, nullable, defaultValue, rawOptions }) {
+		const types = schema.type;
+		const nonNullTypes = types.filter((t) => t !== "null");
+		if (nonNullTypes.length <= 1) return null;
+		const arrayNullable = types.includes("null") || nullable || void 0;
+		return ast.factory.createSchema({
+			type: "union",
+			members: nonNullTypes.map((t) => parseSchema({
+				schema: {
+					...schema,
+					type: t
+				},
+				name
+			}, rawOptions)),
+			...buildSchemaNode(schema, name, arrayNullable, defaultValue)
 		});
 	}
 	/**
-	* Central dispatcher that converts an OAS `SchemaObject` into a `SchemaNode`.
+	* Ordered schema rule table. Order is significant: composition keywords (`$ref`, `allOf`,
+	* `oneOf`/`anyOf`) take precedence over `const`/`format`, which take precedence over the plain
+	* `type`. The first matching rule that produces a node wins. See {@link SchemaRule} for the
+	* match/convert/fall-through contract.
+	*/
+	const schemaRules = [
+		{
+			match: ({ schema }) => dialect.schema.isReference(schema),
+			convert: convertRef
+		},
+		{
+			match: ({ schema }) => !!schema.allOf?.length,
+			convert: convertAllOf
+		},
+		{
+			match: ({ schema }) => !!(schema.oneOf?.length || schema.anyOf?.length),
+			convert: convertUnion
+		},
+		{
+			match: ({ schema }) => "const" in schema && schema.const !== void 0,
+			convert: convertConst
+		},
+		{
+			match: ({ schema }) => !!schema.format,
+			convert: convertFormat
+		},
+		{
+			match: ({ schema }) => dialect.schema.isBinary(schema),
+			convert: convertBlob
+		},
+		{
+			match: ({ schema }) => Array.isArray(schema.type) && schema.type.length > 1,
+			convert: convertMultiType
+		},
+		{
+			match: ({ schema, type }) => !type && (schema.minLength !== void 0 || schema.maxLength !== void 0 || schema.pattern !== void 0),
+			convert: convertString
+		},
+		{
+			match: ({ schema, type }) => !type && (schema.minimum !== void 0 || schema.maximum !== void 0),
+			convert: (ctx) => convertNumeric(ctx, "number")
+		},
+		{
+			match: ({ schema }) => !!schema.enum?.length,
+			convert: convertEnum
+		},
+		{
+			match: ({ schema, type }) => type === "object" || !!schema.properties || !!schema.additionalProperties || "patternProperties" in schema,
+			convert: convertObject
+		},
+		{
+			match: ({ schema }) => "prefixItems" in schema,
+			convert: convertTuple
+		},
+		{
+			match: ({ schema, type }) => type === "array" || "items" in schema,
+			convert: convertArray
+		},
+		{
+			match: ({ type }) => type === "string",
+			convert: convertString
+		},
+		{
+			match: ({ type }) => type === "number",
+			convert: (ctx) => convertNumeric(ctx, "number")
+		},
+		{
+			match: ({ type }) => type === "integer",
+			convert: (ctx) => convertNumeric(ctx, "integer")
+		},
+		{
+			match: ({ type }) => type === "boolean",
+			convert: convertBoolean
+		},
+		{
+			match: ({ type }) => type === "null",
+			convert: ({ schema, name, nullable }) => createNullSchema(schema, name, nullable)
+		}
+	];
+	/**
+	* Converts an OAS `SchemaObject` into a `SchemaNode`.
 	*
-	* Dispatch order (first match wins): `$ref` → `allOf` → `oneOf`/`anyOf` → `const` → `format`
-	* → octet-stream blob → multi-type array → constraint-inferred type → `enum` → object/array/tuple/scalar
-	* → empty-schema fallback (`emptySchemaType` option).
+	* Builds the per-schema context, then walks the ordered {@link schemaRules} table and returns
+	* the first converter that produces a node. When none match, falls back to the configured
+	* `emptySchemaType`.
 	*/
 	function parseSchema({ schema, name }, rawOptions) {
 		const options = {
@@ -1657,81 +1933,53 @@ function createSchemaParser(ctx) {
 			schema: flattenedSchema,
 			name
 		}, rawOptions);
-		const nullable = isNullable(schema) || void 0;
-		const defaultValue = schema.default === null && nullable ? void 0 : schema.default;
-		const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
-		const ctx = {
+		const nullable = dialect.schema.isNullable(schema) || void 0;
+		const schemaCtx = {
 			schema,
 			name,
 			nullable,
-			defaultValue,
-			type,
+			defaultValue: schema.default === null && nullable ? void 0 : schema.default,
+			type: Array.isArray(schema.type) ? schema.type[0] : schema.type,
 			rawOptions,
 			options
 		};
-		if (isReference(schema)) return convertRef(ctx);
-		if (schema.allOf?.length) return convertAllOf(ctx);
-		if ([...schema.oneOf ?? [], ...schema.anyOf ?? []].length) return convertUnion(ctx);
-		if ("const" in schema && schema.const !== void 0) return convertConst(ctx);
-		if (schema.format) {
-			const formatResult = convertFormat(ctx);
-			if (formatResult) return formatResult;
-		}
-		if (schema.type === "string" && schema.contentMediaType === "application/octet-stream") return ast.createSchema({
-			type: "blob",
-			primitive: "string",
-			...buildSchemaNode(schema, name, nullable, defaultValue)
-		});
-		if (Array.isArray(schema.type) && schema.type.length > 1) {
-			const nonNullTypes = schema.type.filter((t) => t !== "null");
-			const arrayNullable = schema.type.includes("null") || nullable || void 0;
-			if (nonNullTypes.length > 1) return ast.createSchema({
-				type: "union",
-				members: nonNullTypes.map((t) => parseSchema({
-					schema: {
-						...schema,
-						type: t
-					},
-					name
-				}, rawOptions)),
-				...buildSchemaNode(schema, name, arrayNullable, defaultValue)
-			});
-		}
-		if (!type) {
-			if (schema.minLength !== void 0 || schema.maxLength !== void 0 || schema.pattern !== void 0) return convertString(ctx);
-			if (schema.minimum !== void 0 || schema.maximum !== void 0) return convertNumeric(ctx, "number");
+		for (const rule of schemaRules) {
+			if (!rule.match(schemaCtx)) continue;
+			const node = rule.convert(schemaCtx);
+			if (node) return node;
 		}
-		if (schema.enum?.length) return convertEnum(ctx);
-		if (type === "object" || schema.properties || schema.additionalProperties || "patternProperties" in schema) return convertObject(ctx);
-		if ("prefixItems" in schema) return convertTuple(ctx);
-		if (type === "array" || "items" in schema) return convertArray(ctx);
-		if (type === "string") return convertString(ctx);
-		if (type === "number") return convertNumeric(ctx, "number");
-		if (type === "integer") return convertNumeric(ctx, "integer");
-		if (type === "boolean") return convertBoolean(ctx);
-		if (type === "null") return convertNull(ctx);
-		const emptyType = typeOptionMap.get(options.emptySchemaType);
-		return ast.createSchema({
+		const emptyType = options.emptySchemaType;
+		return ast.factory.createSchema({
 			type: emptyType,
 			name,
 			title: schema.title,
-			description: schema.description
+			description: schema.description,
+			format: schema.format
 		});
 	}
 	/**
 	* Converts a dereferenced OAS parameter object into a `ParameterNode`.
 	*/
-	function parseParameter(options, param) {
+	function parseParameter(options, param, parentName) {
 		const required = param["required"] ?? false;
-		const schema = param["schema"] ? parseSchema({ schema: param["schema"] }, options) : ast.createSchema({ type: typeOptionMap.get(options.unknownType) });
-		return ast.createParameter({
-			name: param["name"],
+		const paramName = param["name"];
+		const schemaName = parentName && paramName ? pascalCase(`${parentName} ${paramName}`) : void 0;
+		const schema = param["schema"] ? parseSchema({
+			schema: param["schema"],
+			name: schemaName
+		}, options) : ast.factory.createSchema({ type: options.unknownType });
+		const style = param["style"];
+		const explode = param["explode"];
+		return ast.factory.createParameter({
+			name: paramName,
 			in: param["in"],
 			schema: {
 				...schema,
 				description: param["description"] ?? schema.description
 			},
-			required
+			required,
+			...style !== void 0 ? { style } : {},
+			...explode !== void 0 ? { explode } : {}
 		});
 	}
 	/**
@@ -1747,73 +1995,97 @@ function createSchemaParser(ctx) {
 		};
 	}
 	/**
-	* Reads the inline response object (not a `$ref`) and returns its description plus its `content` map.
-	*/
-	function getResponseMeta(responseObj) {
-		if (typeof responseObj !== "object" || responseObj === null || Array.isArray(responseObj)) return {};
-		const inline = responseObj;
-		return {
-			description: inline.description,
-			content: inline.content
-		};
-	}
-	/**
 	* Collects property names whose schema has a truthy boolean flag (`readOnly` or `writeOnly`).
 	* `$ref` entries are skipped since their flags live on the dereferenced target.
 	*/
 	function collectPropertyKeysByFlag(schema, flag) {
-		if (!schema?.properties) return void 0;
+		if (!schema?.properties) return null;
 		const keys = [];
 		for (const key in schema.properties) {
 			const prop = schema.properties[key];
-			if (prop && !isReference(prop) && prop[flag]) keys.push(key);
+			if (prop && !dialect.schema.isReference(prop) && prop[flag]) keys.push(key);
 		}
-		return keys.length ? keys : void 0;
+		return keys.length ? keys : null;
 	}
 	/**
 	* Converts an OAS `Operation` into an `OperationNode`.
 	*/
 	function parseOperation(options, operation) {
-		const parameters = getParameters(document, operation).map((param) => parseParameter(options, param));
+		const operationId = getOperationId(operation);
+		const operationName = operationId ? pascalCase(operationId) : void 0;
+		const parameters = getParameters(document, operation).map((param) => parseParameter(options, param, operationName));
 		const allContentTypes = ctx.contentType ? [ctx.contentType] : getRequestBodyContentTypes(document, operation);
 		const requestBodyMeta = getRequestBodyMeta(operation);
+		const requestBodyName = operationName ? `${operationName}Request` : void 0;
 		const content = allContentTypes.flatMap((ct) => {
 			const schema = getRequestSchema(document, operation, { contentType: ct });
 			if (!schema) return [];
-			return [{
+			return [ast.factory.createContent({
 				contentType: ct,
-				schema: ast.syncOptionality(parseSchema({ schema }, options), requestBodyMeta.required),
+				schema: ast.optionality(parseSchema({
+					schema,
+					name: requestBodyName
+				}, options), requestBodyMeta.required),
 				keysToOmit: collectPropertyKeysByFlag(schema, "readOnly")
-			}];
+			})];
 		});
 		const requestBody = content.length > 0 || requestBodyMeta.description ? {
 			description: requestBodyMeta.description,
 			required: requestBodyMeta.required || void 0,
 			content: content.length > 0 ? content : void 0
 		} : void 0;
-		const responses = operation.getResponseStatusCodes().map((statusCode) => {
-			const responseObj = operation.getResponseByStatusCode(statusCode);
-			const responseSchema = getResponseSchema(document, operation, statusCode, { contentType: ctx.contentType });
-			const schema = responseSchema && Object.keys(responseSchema).length > 0 ? parseSchema({ schema: responseSchema }, options) : ast.createSchema({ type: typeOptionMap.get(options.emptySchemaType) });
-			const { description, content } = getResponseMeta(responseObj);
-			const mediaType = content ? getMediaType(Object.keys(content)[0] ?? "") : getMediaType(operation.contentType ?? "");
-			return ast.createResponse({
+		const responses = getResponseStatusCodes(operation).map((statusCode) => {
+			const responseObj = getResponseByStatusCode({
+				document,
+				operation,
+				statusCode
+			});
+			const responseName = operationName ? `${operationName}Status${statusCode}` : void 0;
+			const description = typeof responseObj === "object" && responseObj !== null ? responseObj.description : void 0;
+			const parseEntrySchema = (contentType) => {
+				const raw = getResponseSchema(document, operation, statusCode, { contentType });
+				return {
+					schema: raw && Object.keys(raw).length > 0 ? parseSchema({
+						schema: raw,
+						name: responseName
+					}, options) : ast.factory.createSchema({ type: options.emptySchemaType }),
+					keysToOmit: collectPropertyKeysByFlag(raw, "writeOnly")
+				};
+			};
+			const content = (ctx.contentType ? [ctx.contentType] : getResponseBodyContentTypes(document, operation, statusCode)).map((contentType) => ast.factory.createContent({
+				contentType,
+				...parseEntrySchema(contentType)
+			}));
+			if (content.length === 0) content.push(ast.factory.createContent({
+				contentType: getRequestContentType({
+					document,
+					operation
+				}) || "application/json",
+				...parseEntrySchema(ctx.contentType)
+			}));
+			return ast.factory.createResponse({
 				statusCode,
 				description,
-				schema,
-				mediaType,
-				keysToOmit: collectPropertyKeysByFlag(responseSchema, "writeOnly")
+				content
 			});
 		});
-		const urlPath = new URLPath(operation.path);
-		return ast.createOperation({
-			operationId: operation.getOperationId(),
+		const pathItem = document.paths?.[operation.path];
+		const pathItemDoc = pathItem && !dialect.schema.isReference(pathItem) ? pathItem : void 0;
+		const pickDoc = (key) => {
+			const own = operation.schema[key];
+			if (typeof own === "string") return own;
+			const fallback = pathItemDoc?.[key];
+			return typeof fallback === "string" ? fallback : void 0;
+		};
+		return ast.factory.createOperation({
+			operationId,
+			protocol: "http",
 			method: operation.method.toUpperCase(),
-			path: urlPath.path,
-			tags: operation.getTags().map((tag) => tag.name),
-			summary: operation.getSummary() || void 0,
-			description: operation.getDescription() || void 0,
-			deprecated: operation.isDeprecated() || void 0,
+			path: operation.path,
+			tags: Array.isArray(operation.schema.tags) ? operation.schema.tags.map(String) : [],
+			summary: pickDoc("summary") || void 0,
+			description: pickDoc("description") || void 0,
+			deprecated: operation.schema.deprecated || void 0,
 			parameters,
 			requestBody,
 			responses
@@ -1825,59 +2097,267 @@ function createSchemaParser(ctx) {
 		parseParameter
 	};
 }
+//#endregion
+//#region src/promoteEnums.ts
+/**
+* Collects inline enums to lift to the top level, keyed by the name the parser derived for them
+* (e.g. `PetStatusEnum`). An enum already defined as a top-level component is left as-is, and a
+* name that recurs maps to the first definition so each name yields one shared type.
+*/
+function collectInlineEnums(roots, topLevelNames) {
+	const promoted = /* @__PURE__ */ new Map();
+	for (const root of roots) {
+		const isSchemaRoot = root.kind === "Schema";
+		for (const node of ast.collect(root, { schema: (schemaNode) => schemaNode })) {
+			if (node.type !== "enum" || !node.name) continue;
+			if ((node.namedEnumValues ?? node.enumValues ?? []).length === 1) continue;
+			if (isSchemaRoot && node === root) continue;
+			if (topLevelNames.has(node.name)) continue;
+			if (!promoted.has(node.name)) promoted.set(node.name, {
+				...node,
+				optional: void 0,
+				nullish: void 0
+			});
+		}
+	}
+	return promoted;
+}
+/**
+* Replaces every promoted inline enum in `node` with a `ref` to its lifted definition, keeping the
+* occurrence's usage-slot and documentation fields.
+*/
+function refPromotedEnums(node, promoted) {
+	if (promoted.size === 0) return node;
+	return ast.transform(node, { schema(schemaNode) {
+		if (schemaNode.type !== "enum" || !schemaNode.name || !promoted.has(schemaNode.name)) return void 0;
+		return ast.factory.createSchema({
+			type: "ref",
+			name: schemaNode.name,
+			ref: `${SCHEMA_REF_PREFIX}${schemaNode.name}`,
+			optional: schemaNode.optional,
+			nullish: schemaNode.nullish,
+			readOnly: schemaNode.readOnly,
+			writeOnly: schemaNode.writeOnly,
+			deprecated: schemaNode.deprecated,
+			description: schemaNode.description,
+			default: schemaNode.default,
+			examples: schemaNode.examples
+		});
+	} });
+}
+//#endregion
+//#region src/schemaDiagnostics.ts
+/**
+* Reports the advisory diagnostics (`KUBB_UNSUPPORTED_FORMAT`, `KUBB_DEPRECATED`) for one
+* top-level schema. Walks the node the parser produced during `preScan`, threading the RFC 6901
+* pointer as it descends so a nested field reports against its full path
+* (`#/components/schemas/Pet/properties/owner/properties/name`). Refs are not followed, so the
+* resolved schema is reported under its own walk. Reports land in the active build run, are a
+* no-op outside one, and repeats are deduped by the build.
+*/
+function reportSchemaDiagnostics({ node, name }) {
+	visit(node, `#/components/schemas/${escapePointerToken(name)}`);
+}
+/**
+* Escapes a single JSON pointer reference token per RFC 6901 (`~` → `~0`, `/` → `~1`), so a
+* property name with those characters maps to a distinct pointer instead of colliding in the dedupe.
+*/
+function escapePointerToken(token) {
+	return token.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function visit(node, pointer) {
+	if (node.deprecated) Diagnostics.report({
+		code: Diagnostics.code.deprecated,
+		severity: "info",
+		message: "This schema is marked as deprecated.",
+		location: {
+			kind: "schema",
+			pointer
+		}
+	});
+	if (typeof node.format === "string" && !isHandledFormat(node.format)) Diagnostics.report({
+		code: Diagnostics.code.unsupportedFormat,
+		severity: "warning",
+		message: `Kubb does not map the format "${node.format}" to a specific type, so it falls back to the base type.`,
+		help: `Use a format Kubb supports, or handle "${node.format}" with a custom parser or plugin.`,
+		location: {
+			kind: "schema",
+			pointer
+		}
+	});
+	if (node.type === "object") {
+		for (const property of node.properties) visit(property.schema, `${pointer}/properties/${escapePointerToken(property.name)}`);
+		if (node.additionalProperties && typeof node.additionalProperties === "object") visit(node.additionalProperties, `${pointer}/additionalProperties`);
+		return;
+	}
+	if (node.type === "array") {
+		for (const item of node.items ?? []) visit(item, `${pointer}/items`);
+		return;
+	}
+	if (node.type === "tuple") {
+		for (const [index, item] of (node.items ?? []).entries()) visit(item, `${pointer}/items/${index}`);
+		return;
+	}
+	if (node.type === "union" || node.type === "intersection") for (const [index, member] of (node.members ?? []).entries()) visit(member, `${pointer}/members/${index}`);
+}
+//#endregion
+//#region src/stream.ts
+/**
+* Reads the server URL from the document's `servers` array at `server.index`,
+* interpolating any `server.variables` into the URL template.
+*
+* Returns `null` when `server.index` is omitted or out of range.
+*
+* @example Resolve the first server
+* `resolveBaseUrl({ document, server: { index: 0 } })`
+*
+* @example Override a path variable
+* `resolveBaseUrl({ document, server: { index: 0, variables: { version: 'v2' } } })`
+*/
+function resolveBaseUrl({ document, server }) {
+	const index = server?.index;
+	const entry = index !== void 0 ? document.servers?.at(index) : void 0;
+	return entry?.url ? resolveServerUrl(entry, server?.variables) : null;
+}
 /**
-* Parses an OpenAPI specification into Kubb's universal `InputNode` AST.
+* Parses every schema once to build the lookup structures that streaming needs upfront.
+*
+* Three things happen in this single pass:
+* - `refAliasMap` records schemas that are pure `$ref` aliases so the streaming pass can inline them.
+* - `enumNames` collects the names of every enum schema so plugins skip re-scanning the stream.
+* - `circularNames` runs cycle detection, which requires all nodes in memory simultaneously.
+*   The `allNodes` array is local and drops out of scope as soon as this function returns.
 *
-* This is the main entry point for `@kubb/adapter-oas`. It converts OpenAPI/Swagger specs into a spec-agnostic tree
-* that downstream plugins (`plugin-ts`, `plugin-zod`, etc.) consume for code generation. No code is generated here —
-* the tree is a pure data structure representing all schemas and operations.
+* After this call, only `refAliasMap` and `discriminatorChildMap` stay alive in the adapter closure.
+* Both are proportional to the number of aliases or discriminator parents, not total schema count.
 *
-* Returns the AST root and a `nameMapping` for resolving schema references.
+* Each schema is parsed again during the streaming pass. This is intentional.
+* Holding the parsed nodes in memory here would defeat the streaming memory benefit.
 *
 * @example
 * ```ts
-* import { parseOas } from '@kubb/adapter-oas'
-*
-* const document = await parseFromConfig(config)
-* const { root, nameMapping } = parseOas(document, { dateType: 'date', contentType: 'application/json' })
+* const { refAliasMap, enumNames, circularNames } = preScan({
+*   schemas,
+*   parseSchema,
+*   parserOptions,
+*   discriminator: 'preserve',
+* })
 * ```
 */
-function parseOas(document, options = {}) {
-	const { contentType, ...parserOptions } = options;
-	const mergedOptions = {
-		...DEFAULT_PARSER_OPTIONS,
-		...parserOptions
-	};
-	const { schemas: schemaObjects, nameMapping } = getSchemas(document, { contentType });
-	const { parseSchema: _parseSchema, parseOperation: _parseOperation } = createSchemaParser({
-		document,
-		contentType
-	});
-	const schemas = Object.entries(schemaObjects).map(([name, schema]) => _parseSchema({
-		schema,
-		name
-	}, mergedOptions));
-	const paths = new BaseOas(document).getPaths();
-	const operations = Object.entries(paths).flatMap(([_path, methods]) => Object.entries(methods).map(([, operation]) => operation ? _parseOperation(mergedOptions, operation) : null).filter((op) => op !== null));
+function preScan({ schemas, parseSchema, parseOperation, document, parserOptions, discriminator, enums = "inline" }) {
+	const allNodes = [];
+	const refAliasMap = /* @__PURE__ */ new Map();
+	const enumNames = [];
+	const discriminatorParentNodes = [];
+	for (const [name, schema] of Object.entries(schemas)) {
+		const node = parseSchema({
+			schema,
+			name
+		}, parserOptions);
+		allNodes.push(node);
+		reportSchemaDiagnostics({
+			node,
+			name
+		});
+		if (node.type === "ref" && node.name && node.name !== name) refAliasMap.set(name, node);
+		const enumNode = ast.narrowSchema(node, ast.schemaTypes.enum);
+		const isConstEnum = (enumNode?.namedEnumValues ?? enumNode?.enumValues ?? []).length === 1;
+		if (enumNode && node.name && !isConstEnum) enumNames.push(node.name);
+		if (discriminator === "propagate" && (schema.oneOf ?? schema.anyOf) && schema.discriminator?.propertyName) discriminatorParentNodes.push(node);
+	}
+	const circularNames = [...findCircularSchemas(allNodes)];
+	const discriminatorChildMap = discriminatorParentNodes.length > 0 ? buildDiscriminatorChildMap(discriminatorParentNodes) : null;
+	let promotedEnums = null;
+	if (enums === "root" && document && parseOperation) {
+		const operationNodes = [];
+		for (const operation of getOperations(document)) {
+			const operationNode = parseOperation(parserOptions, operation);
+			if (operationNode) operationNodes.push(operationNode);
+		}
+		promotedEnums = collectInlineEnums([...allNodes, ...operationNodes], new Set(Object.keys(schemas)));
+		for (const name of promotedEnums.keys()) enumNames.push(name);
+	}
 	return {
-		root: ast.createInput({
-			schemas,
-			operations
-		}),
-		nameMapping
+		refAliasMap,
+		enumNames,
+		circularNames,
+		discriminatorChildMap,
+		promotedEnums
 	};
 }
+/**
+* Creates a lazy `InputNode<true>` from already-resolved adapter state.
+*
+* The schema and operation iterables each start a fresh parse pass on every
+* `[Symbol.asyncIterator]()` call. This lets multiple plugins consume the same
+* stream object independently without sharing a cursor or holding all nodes in memory.
+*
+* Ref aliases in `refAliasMap` are inlined during iteration: an alias entry is replaced
+* with its target's parsed node (but keeps the alias name) so plugins never receive bare `ref` nodes.
+*
+* @example
+* ```ts
+* const streamNode = createInputStream({ schemas, parseSchema, parseOperation, document, parserOptions, refAliasMap, discriminatorChildMap, meta })
+* for await (const schema of streamNode.schemas) {
+*   // each call to for-await restarts from the first schema
+* }
+* ```
+*/
+function createInputStream({ schemas, parseSchema, parseOperation, document, parserOptions, refAliasMap, discriminatorChildMap, promotedEnums, meta }) {
+	const schemasIterable = { [Symbol.asyncIterator]() {
+		return (async function* () {
+			if (promotedEnums) for (const definition of promotedEnums.values()) yield definition;
+			for (const [name, schema] of Object.entries(schemas)) {
+				const alias = refAliasMap.get(name);
+				if (alias?.name && schemas[alias.name]) {
+					const aliasNode = {
+						...parseSchema({
+							schema: schemas[alias.name],
+							name: alias.name
+						}, parserOptions),
+						name
+					};
+					yield promotedEnums ? refPromotedEnums(aliasNode, promotedEnums) : aliasNode;
+					continue;
+				}
+				const parsed = parseSchema({
+					schema,
+					name
+				}, parserOptions);
+				const node = discriminatorChildMap?.get(name) ? patchDiscriminatorNode(parsed, discriminatorChildMap.get(name)) : parsed;
+				yield promotedEnums ? refPromotedEnums(node, promotedEnums) : node;
+			}
+		})();
+	} };
+	const operationsIterable = { [Symbol.asyncIterator]() {
+		return (async function* () {
+			for (const operation of getOperations(document)) {
+				const node = parseOperation(parserOptions, operation);
+				if (node) yield promotedEnums ? refPromotedEnums(node, promotedEnums) : node;
+			}
+		})();
+	} };
+	return ast.factory.createInput({
+		stream: true,
+		schemas: schemasIterable,
+		operations: operationsIterable,
+		meta
+	});
+}
 //#endregion
 //#region src/adapter.ts
 /**
-* Stable string identifier for the OAS adapter used in Kubb's adapter registry.
+* The `name` of `@kubb/adapter-oas`, used to identify this adapter in a Kubb config.
 */
 const adapterOasName = "oas";
 /**
-* Creates the default OpenAPI / Swagger adapter for Kubb.
+* Default Kubb adapter for OpenAPI 2.0, 3.0, and 3.1 specifications. Reads the
+* file at `input.path`, validates it, resolves the base URL, and converts every
+* schema and operation into the universal AST that every downstream plugin
+* consumes.
 *
-* Parses the spec, optionally validates it, resolves the base URL, and converts
-* everything into an `InputNode` that downstream plugins consume.
+* Configure once on `defineConfig`. The adapter's choices (date representation,
+* integer width, server URL) apply to every plugin in the build.
 *
 * @example
 * ```ts
@@ -1886,26 +2366,117 @@ const adapterOasName = "oas";
 * import { pluginTs } from '@kubb/plugin-ts'
 *
 * export default defineConfig({
-*   adapter: adapterOas({ dateType: 'date', serverIndex: 0 }),
-*   input: { path: './openapi.yaml' },
+*   input: { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   adapter: adapterOas({
+*     server: { index: 0 },
+*     discriminator: 'propagate',
+*     dateType: 'date',
+*   }),
 *   plugins: [pluginTs()],
 * })
 * ```
 */
 const adapterOas = createAdapter((options) => {
-	const { validate = true, contentType, serverIndex, serverVariables, discriminator = "strict", dateType = DEFAULT_PARSER_OPTIONS.dateType, integerType = DEFAULT_PARSER_OPTIONS.integerType, unknownType = DEFAULT_PARSER_OPTIONS.unknownType, enumSuffix = DEFAULT_PARSER_OPTIONS.enumSuffix, emptySchemaType = unknownType || DEFAULT_PARSER_OPTIONS.emptySchemaType } = options;
+	const { validate = true, contentType, server, discriminator = "preserve", enums = "inline", dateType = DEFAULT_PARSER_OPTIONS.dateType, integerType = DEFAULT_PARSER_OPTIONS.integerType, unknownType = DEFAULT_PARSER_OPTIONS.unknownType, enumSuffix = DEFAULT_PARSER_OPTIONS.enumSuffix, emptySchemaType = unknownType || DEFAULT_PARSER_OPTIONS.emptySchemaType } = options;
+	const parserOptions = {
+		...DEFAULT_PARSER_OPTIONS,
+		dateType,
+		integerType,
+		unknownType,
+		emptySchemaType,
+		enumSuffix
+	};
 	let nameMapping = /* @__PURE__ */ new Map();
-	let parsedDocument;
-	let inputNode;
+	let parsedDocument = null;
+	const documentCache = /* @__PURE__ */ new WeakMap();
+	const schemasCache = /* @__PURE__ */ new WeakMap();
+	const schemaParserCache = /* @__PURE__ */ new WeakMap();
+	const preScanCache = /* @__PURE__ */ new WeakMap();
+	function ensureDocument(source) {
+		const cached = documentCache.get(source);
+		if (cached) return cached;
+		const promise = (async () => {
+			const fresh = await parseFromConfig(source);
+			if (validate) await validateDocument(fresh);
+			parsedDocument = fresh;
+			return fresh;
+		})();
+		documentCache.set(source, promise);
+		return promise;
+	}
+	function ensureSchemas(document) {
+		const cached = schemasCache.get(document);
+		if (cached) return cached;
+		const promise = Promise.resolve().then(() => {
+			const result = getSchemas(document, { contentType });
+			nameMapping = result.nameMapping;
+			return result.schemas;
+		});
+		schemasCache.set(document, promise);
+		return promise;
+	}
+	function ensureSchemaParser(document) {
+		const cached = schemaParserCache.get(document);
+		if (cached) return cached;
+		const parser = createSchemaParser({
+			document,
+			contentType
+		});
+		schemaParserCache.set(document, parser);
+		return parser;
+	}
+	function ensurePreScan(document, schemas, parseSchema, parseOperation) {
+		const cached = preScanCache.get(document);
+		if (cached) return cached;
+		const result = preScan({
+			schemas,
+			parseSchema,
+			parseOperation,
+			document,
+			parserOptions,
+			discriminator,
+			enums
+		});
+		preScanCache.set(document, result);
+		return result;
+	}
+	async function createStream(source) {
+		const document = await ensureDocument(source);
+		const schemas = await ensureSchemas(document);
+		const { parseSchema, parseOperation } = ensureSchemaParser(document);
+		const { refAliasMap, enumNames, circularNames, discriminatorChildMap, promotedEnums } = ensurePreScan(document, schemas, parseSchema, parseOperation);
+		return createInputStream({
+			schemas,
+			parseSchema,
+			parseOperation,
+			document,
+			parserOptions,
+			refAliasMap,
+			discriminatorChildMap,
+			promotedEnums,
+			meta: {
+				title: document.info?.title,
+				description: document.info?.description,
+				version: document.info?.version,
+				baseURL: resolveBaseUrl({
+					document,
+					server
+				}),
+				circularNames,
+				enumNames
+			}
+		});
+	}
 	return {
 		name: "oas",
 		get options() {
 			return {
 				validate,
 				contentType,
-				serverIndex,
-				serverVariables,
+				server,
 				discriminator,
+				enums,
 				dateType,
 				integerType,
 				unknownType,
@@ -1917,65 +2488,36 @@ const adapterOas = createAdapter((options) => {
 		get document() {
 			return parsedDocument;
 		},
-		get inputNode() {
-			return inputNode;
+		async validate(input, options) {
+			await assertInputExists(input);
+			await validateDocument(await parseDocument(input), options);
 		},
 		getImports(node, resolve) {
-			return ast.collectImports({
-				node,
-				nameMapping,
-				resolve: (schemaName) => {
-					const result = resolve(schemaName);
-					if (!result) return;
-					return ast.createImport({
-						name: [result.name],
-						path: result.path
-					});
-				}
-			});
+			return collect(node, { schema(schemaNode) {
+				const schemaRef = narrowSchema(schemaNode, "ref");
+				if (!schemaRef?.ref) return null;
+				const rawName = extractRefName(schemaRef.ref);
+				const result = resolve(nameMapping.get(rawName) ?? rawName);
+				if (!result) return null;
+				return ast.factory.createImport({
+					name: [result.name],
+					path: result.path
+				});
+			} });
 		},
 		async parse(source) {
-			const document = await parseFromConfig(source);
-			if (validate) await validateDocument(document);
-			const server = serverIndex !== void 0 ? document.servers?.at(serverIndex) : void 0;
-			const baseURL = server?.url ? resolveServerUrl(server, serverVariables) : void 0;
-			const { root: parsedRoot, nameMapping: parsedNameMapping } = parseOas(document, {
-				contentType,
-				dateType,
-				integerType,
-				unknownType,
-				emptySchemaType,
-				enumSuffix
+			const streamNode = await createStream(source);
+			const [schemas, operations] = await Promise.all([Array.fromAsync(streamNode.schemas), Array.fromAsync(streamNode.operations)]);
+			return ast.factory.createInput({
+				schemas,
+				operations,
+				meta: streamNode.meta
 			});
-			const node = discriminator === "inherit" ? applyDiscriminatorInheritance(parsedRoot) : parsedRoot;
-			nameMapping = parsedNameMapping;
-			parsedDocument = document;
-			inputNode = ast.createInput({
-				...node,
-				meta: {
-					title: document.info?.title,
-					description: document.info?.description,
-					version: document.info?.version,
-					baseURL
-				}
-			});
-			return inputNode;
-		}
+		},
+		stream: createStream
 	};
 });
 //#endregion
-//#region src/types.ts
-/**
-* Maps uppercase HTTP method names to lowercase for backwards compatibility.
-*
-* @example
-* ```ts
-* HttpMethods['GET'] // 'get'
-* HttpMethods['POST'] // 'post'
-* ```
-*/
-const HttpMethods = Object.fromEntries(Object.entries(ast.httpMethods).map(([lower, upper]) => [upper, lower]));
-//#endregion
-export { HttpMethods, adapterOas, adapterOasName, mergeDocuments, parseDocument, parseFromConfig, validateDocument };
+export { adapterOas, adapterOasName };
 
 //# sourceMappingURL=index.js.map