@kubb/adapter-oas 5.0.0-beta.6 → 5.0.0-beta.61

package/dist/index.js

@@ -1,12 +1,13 @@
-import "./chunk--u3MIqq1.js";
-import { ast, createAdapter } from "@kubb/core";
+import "./chunk-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 { parse } from "yaml";
+import { bundle } from "api-ref-bundler";
+import { macroDiscriminatorEnum, macroEnumName, macroSimplifyUnion } from "@kubb/ast/macros";
+import { childName, containsCircularRef, 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.
@@ -38,6 +39,20 @@ const DEFAULT_PARSER_OPTIONS = {
 */
 const SCHEMA_REF_PREFIX = "#/components/schemas/";
 /**
+* HTTP methods that count as operations on an OpenAPI path item. Other keys
+* (`parameters`, `summary`, `$ref`, vendor extensions) are skipped when iterating operations.
+*/
+const SUPPORTED_METHODS = new Set([
+	"get",
+	"put",
+	"post",
+	"delete",
+	"options",
+	"head",
+	"patch",
+	"trace"
+]);
+/**
 * OpenAPI version string written into the stub document created during multi-spec merges.
 */
 const MERGE_OPENAPI_VERSION = "3.0.0";
@@ -77,7 +92,7 @@ const structuralKeys = new Set([
 *
 * 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
+* 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
@@ -89,6 +104,18 @@ const structuralKeys = new Set([
 * formatMap['float']  // 'number'
 * ```
 */
+/**
+* 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"
+]);
 const formatMap = {
 	uuid: "uuid",
 	email: "email",
@@ -118,8 +145,8 @@ 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()`.
+* Maps the `unknownType`/`emptySchemaType` option string to its `ScalarSchemaType` constant.
+* A `Map` (over a plain object) lets callers test key membership with `.has()`.
 */
 const typeOptionMap = new Map([
 	["any", ast.schemaTypes.any],
@@ -127,87 +154,6 @@ const typeOptionMap = new Map([
 	["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.
-*
-* @example
-* ```ts
-* const { root } = parseOas(document, options)
-* const next = applyDiscriminatorInheritance(root)
-* ```
-*/
-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
-		};
-	} });
-}
-//#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -219,57 +165,132 @@ 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.
+* Converts `text` to camelCase.
 *
-* Only splits on dots followed by a letter so that version numbers
-* embedded in operationIds (e.g. `v2025.0`) are kept intact.
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
 *
-* 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.
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
 */
-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("/");
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 /**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+* Converts `text` to PascalCase.
+*
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
+*
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
+*/
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+}
+//#endregion
+//#region ../../internals/utils/src/runtime.ts
+/**
+* Detects the JavaScript runtime executing the current process and exposes its name and version.
+*
+* Prefer the shared {@link runtime} instance over constructing your own.
+*/
+var Runtime = class {
+	/**
+	* `true` when the current process is running under Bun.
+	*
+	* 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
+	* if (runtime.isBun) {
+	*   await Bun.write(path, data)
+	* }
+	* ```
+	*/
+	get isBun() {
+		return typeof Bun !== "undefined";
+	}
+	/**
+	* `true` when the current process is running under Deno.
+	*/
+	get isDeno() {
+		return typeof globalThis.Deno !== "undefined";
+	}
+	/**
+	* `true` when the current process is running under Node.
+	*
+	* Bun and Deno are excluded first so a polyfilled `process` does not register as Node.
+	*/
+	get isNode() {
+		return !this.isBun && !this.isDeno && typeof process !== "undefined" && process.versions?.node != null;
+	}
+	/**
+	* Name of the runtime executing the current process.
+	*
+	* @example
+	* ```ts
+	* runtime.name // 'bun' when run with `bun kubb`, 'node' otherwise
+	* ```
+	*/
+	get name() {
+		if (this.isBun) return "bun";
+		if (this.isDeno) return "deno";
+		return "node";
+	}
+	/**
+	* Version of the active runtime, or an empty string when it cannot be read.
+	*
+	* @example
+	* ```ts
+	* runtime.version // '1.3.11' under Bun, '22.22.2' under Node
+	* ```
+	*/
+	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 ../../internals/utils/src/fs.ts
+/**
+* Resolves to `true` when the file or directory at `path` exists.
+* Uses `Bun.file().exists()` when running under Bun, `fs.access` otherwise.
 *
 * @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);
+* ```ts
+* if (await exists('./kubb.config.ts')) {
+*   const content = await read('./kubb.config.ts')
+* }
+* ```
+*/
+async function exists(path) {
+	if (runtime.isBun) return Bun.file(path).exists();
+	return access(path).then(() => true, () => false);
 }
 /**
-* Converts `text` to PascalCase.
-* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+* Reads the file at `path` as a UTF-8 string.
+* Uses `Bun.file().text()` when running under Bun, `fs.readFile` otherwise.
 *
 * @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);
+* ```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 ../../internals/utils/src/object.ts
@@ -406,102 +427,99 @@ const reservedWords = new Set([
 */
 function isValidVarName(name) {
 	if (!name || reservedWords.has(name)) return false;
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+	return isIdentifier(name);
 }
-//#endregion
-//#region ../../internals/utils/src/urlPath.ts
 /**
-* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
+* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
+*
+* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
+* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
+* deciding whether an object key needs quoting.
 *
 * @example
-* const p = new URLPath('/pet/{petId}')
-* p.URL      // '/pet/:petId'
-* p.template // '`/pet/${petId}`'
+* ```ts
+* isIdentifier('name')   // true
+* isIdentifier('x-total')// false
+* ```
 */
-var URLPath = class {
-	/**
-	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
-	*/
-	path;
-	#options;
-	constructor(path, options = {}) {
-		this.path = path;
-		this.#options = options;
+function isIdentifier(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+//#endregion
+//#region ../../internals/utils/src/url.ts
+function transformParam(raw, casing) {
+	const param = isValidVarName(raw) ? raw : camelCase(raw);
+	return casing === "camelcase" ? camelCase(param) : param;
+}
+function toParamsObject(path, { replacer, casing } = {}) {
+	const params = {};
+	for (const match of path.matchAll(/\{([^}]+)\}/g)) {
+		const param = transformParam(match[1], casing);
+		const key = replacer ? replacer(param) : param;
+		params[key] = key;
 	}
-	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+	return Object.keys(params).length > 0 ? params : null;
+}
+/**
+* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
+*/
+var Url = class Url {
+	/**
+	* Reports whether `url` is a parseable absolute URL. Delegates to the native `URL.canParse`.
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').URL // '/pet/:petId'
-	* ```
+	* Url.canParse('https://petstore.swagger.io/v2') // true
+	* Url.canParse('/pet/{petId}')                   // false
 	*/
-	get URL() {
-		return this.toURLPath();
+	static canParse(url, base) {
+		return URL.canParse(url, base);
 	}
-	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+	/**
+	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
 	*
 	* @example
-	* ```ts
-	* new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
-	* new URLPath('/pet/{petId}').isURL                       // false
-	* ```
+	* Url.toPath('/pet/{petId}') // '/pet/:petId'
 	*/
-	get isURL() {
-		try {
-			return !!new URL(this.path).href;
-		} catch {
-			return false;
-		}
+	static toPath(path) {
+		return path.replace(/\{([^}]+)\}/g, ":$1");
 	}
 	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
+	* Converts an OpenAPI/Swagger path to a TypeScript template literal string.
+	* `prefix` is prepended inside the literal, `replacer` transforms each parameter name,
+	* and `casing` controls parameter identifier casing.
 	*
 	* @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.
+	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').object
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	* ```
+	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
 	*/
-	get object() {
-		return this.toObject();
+	static toTemplateString(path, { prefix, replacer, casing } = {}) {
+		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = transformParam(part, casing);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("");
+		return `\`${prefix ?? ""}${result}\``;
 	}
-	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+	/**
+	* 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}').params // { petId: 'petId' }
-	* new URLPath('/pet').params         // undefined
-	* ```
-	*/
-	get params() {
-		return this.getParams();
-	}
-	#transformParam(raw) {
-		const param = isValidVarName(raw) ? raw : camelCase(raw);
-		return this.#options.casing === "camelcase" ? camelCase(param) : param;
-	}
-	/**
-	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+	* Url.toObject('/pet/{petId}')
+	* // { url: '/pet/:petId', params: { petId: 'petId' } }
 	*/
-	#eachParam(fn) {
-		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
-			const raw = match[1];
-			fn(raw, this.#transformParam(raw));
-		}
-	}
-	toObject({ type = "path", replacer, stringify } = {}) {
+	static toObject(path, { type = "path", replacer, stringify, casing } = {}) {
 		const object = {
-			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-			params: this.getParams()
+			url: type === "path" ? Url.toPath(path) : Url.toTemplateString(path, {
+				replacer,
+				casing
+			}),
+			params: toParamsObject(path, {
+				replacer,
+				casing
+			})
 		};
 		if (stringify) {
 			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
@@ -510,51 +528,52 @@ var URLPath = class {
 		}
 		return object;
 	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	* An optional `replacer` can transform each extracted parameter name before interpolation.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
-	*/
-	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("")}\``;
-	}
-	/**
-	* 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.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}/tag/{tagId}').getParams()
-	* // { petId: 'petId', tagId: 'tagId' }
-	* ```
-	*/
-	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;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
-	* ```
-	*/
-	toURLPath() {
-		return this.path.replace(/\{([^}]+)\}/g, ":$1");
-	}
 };
 //#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/guards.ts
 /**
 * Returns `true` when `doc` is a Swagger 2.0 document (no `openapi` key).
@@ -619,9 +638,10 @@ function isDiscriminator(obj) {
 /**
 * Loads and dereferences an OpenAPI document, returning the raw `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 a file path string or an already-parsed document object. File paths and URLs are
+* bundled via `api-ref-bundler`, hoisting external file schemas into named `components.schemas`
+* entries so generators can emit named types and imports. Swagger 2.0 documents are
+* automatically up-converted to OpenAPI 3.0 via `swagger2openapi`.
 *
 * @example
 * ```ts
@@ -629,20 +649,11 @@ function isDiscriminator(obj) {
 * const document = await parse(rawDocumentObject, { canBundle: false })
 * ```
 */
-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();
+async function parseDocument(pathOrApi, { canBundle = true } = {}) {
+	if (typeof pathOrApi === "string" && canBundle) return parseDocument(await bundleDocument(pathOrApi), { canBundle: false });
+	const document = typeof pathOrApi === "string" ? parse(pathOrApi) : pathOrApi;
 	if (isOpenApiV2Document(document)) {
+		const { default: swagger2openapi } = await import("swagger2openapi");
 		const { openapi } = await swagger2openapi.convertObj(document, { anchors: true });
 		return openapi;
 	}
@@ -651,7 +662,7 @@ async function parseDocument(pathOrApi, { canBundle = true, enablePaths = true }
 /**
 * Deep-merges multiple OpenAPI documents into a single `Document`.
 *
-* Each document is parsed independently then recursively merged via `mergeDeep` from `@internals/utils`.
+* Each document is parsed independently, then deep-merged into one in array order.
 * Throws when the input array is empty.
 *
 * @example
@@ -660,12 +671,14 @@ async function parseDocument(pathOrApi, { canBundle = true, enablePaths = true }
 * ```
 */
 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 documents = await Promise.all(pathOrApi.map((p) => parseDocument(p, { canBundle: false })));
+	if (documents.length === 0) throw new Diagnostics.Error({
+		code: Diagnostics.code.inputRequired,
+		severity: "error",
+		message: "No OAS documents were provided for merging.",
+		help: "Pass at least one path or document to `input.path`.",
+		location: { kind: "config" }
+	});
 	const seed = {
 		openapi: MERGE_OPENAPI_VERSION,
 		info: {
@@ -681,9 +694,9 @@ async function mergeDocuments(pathOrApi) {
 * Creates a `Document` from an `AdapterSource`.
 *
 * 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.
+* - `{ 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.
 *
 * @example
 * ```ts
@@ -691,17 +704,34 @@ async function mergeDocuments(pathOrApi) {
 * const document = await parseFromConfig({ type: 'data', data: '{"openapi":"3.0.0",...}' })
 * ```
 */
-function parseFromConfig(source) {
+async function parseFromConfig(source) {
 	if (source.type === "data") {
 		if (typeof source.data === "object") return parseDocument(structuredClone(source.data));
 		return parseDocument(source.data, { canBundle: false });
 	}
 	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));
+	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);
 }
 /**
-* Validates an OpenAPI document using `oas-normalize` with colorized error output.
+* 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
@@ -710,56 +740,374 @@ function parseFromConfig(source) {
 */
 async function validateDocument(document, { throwOnError = false } = {}) {
 	try {
-		await new OASNormalize(document, {
-			enablePaths: true,
-			colorizeErrors: true
-		}).validate({ parser: { validate: { errors: { colorize: true } } } });
+		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/refs.ts
+//#endregion
+//#region src/refs.ts
+const _refCache = /* @__PURE__ */ new WeakMap();
+/**
+* Resolves a local JSON pointer reference from a document.
+*
+* Accepts `#/...` refs. Returns `null` for empty or non-local refs.
+* Throws when the pointer cannot be resolved.
+*
+* @example
+* ```ts
+* resolveRef<SchemaObject>(document, '#/components/schemas/Pet') // SchemaObject | null
+* ```
+*/
+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);
+	}
+	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;
+}
+/**
+* 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.
+*
+* @example
+* ```ts
+* dereferenceWithRef(document, { $ref: '#/components/schemas/Pet' })
+* // { $ref: '#/components/schemas/Pet', type: 'object', properties: { ... } }
+* ```
+*/
+function dereferenceWithRef(document, schema) {
+	if (isReference(schema)) return {
+		...schema,
+		...resolveRef(document, schema.$ref),
+		$ref: schema.$ref
+	};
+	return schema;
+}
+//#endregion
+//#region src/dialect.ts
+/**
+* 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.
+*
+* Formats (`uuid`, `email`, dates, …) are intentionally NOT here: they are shared
+* JSON Schema vocabulary, so the converters keep that common case.
+*
+* @example
+* ```ts
+* const parser = createSchemaParser(context)             // uses oasDialect
+* const parser = createSchemaParser(context, oasDialect) // explicit
+* ```
+*/
+const oasDialect = ast.defineSchemaDialect({
+	name: "oas",
+	isNullable,
+	isReference,
+	isDiscriminator,
+	isBinary: (schema) => schema.type === "string" && schema.contentMediaType === "application/octet-stream",
+	resolveRef
+});
+//#endregion
+//#region src/discriminator.ts
+/**
+* Builds a map of child schema names → 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;
+}
+/**
+* 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
+* createDiscriminantNode({ propertyName: 'type', value: 'dog' })
+* // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
+* ```
+*/
+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/mime.ts
+/**
+* MIME type fragments that mark a media type as JSON-like.
+*
+* Matches the substrings used by the `oas` library's `matchesMimeType.json`, so a content type is
+* JSON when it contains any of these. 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
+* isJsonMimeType('application/json')         // true
+* isJsonMimeType('application/vnd.api+json') // true
+* isJsonMimeType('multipart/form-data')      // false
+* ```
+*/
+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;
+}
 /**
-* Resolves a local JSON pointer reference from a document.
-*
-* Accepts `#/...` refs. Returns `null` for empty or non-local refs.
-* Throws when the pointer cannot be resolved.
-*
-* @example
-* ```ts
-* resolveRef<SchemaObject>(document, '#/components/schemas/Pet') // SchemaObject | null
-* ```
+* 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 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 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;
 }
 /**
-* 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.
+* Returns the primary request content type. Prefers a JSON-like media type (the last one wins,
+* matching the previous behavior), 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;
+}
+/**
+* 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 +1131,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 +1153,15 @@ function getSchemaType(format) {
 	return formatMap[format] ?? null;
 }
 /**
+* Whether the parser maps `format` to a dedicated type. True for any `formatMap` entry and the
+* `specialCasedFormats` `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,12 +1171,6 @@ 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.
@@ -842,7 +1202,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;
 	}
@@ -873,7 +1233,11 @@ function getResponseSchema(document, operation, statusCode, options = {}) {
 			if (schema && isReference(schema)) responses[key] = resolveRef(document, schema.$ref);
 		}
 	}
-	const responseBody = getResponseBody(operation.getResponseByStatusCode(statusCode), options.contentType);
+	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,7 +1253,11 @@ 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 schema = Array.isArray(requestBody) ? requestBody[1].schema : requestBody.schema;
 	if (!schema) return null;
@@ -898,7 +1266,7 @@ function getRequestSchema(document, operation, options = {}) {
 /**
 * 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.
 *
@@ -908,7 +1276,7 @@ function getRequestSchema(document, operation, options = {}) {
 * // { type: 'object', properties: {}, description: 'A pet' }
 *
 * flattenSchema({ allOf: [{ $ref: '#/components/schemas/Pet' }] })
-* // returned unchanged — contains a $ref
+* // returned unchanged, contains a $ref
 * ```
 */
 /**
@@ -924,7 +1292,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 +1302,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 +1321,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 +1352,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) {
@@ -1074,7 +1443,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;
@@ -1118,15 +1487,16 @@ function buildSchemaNode(schema, name, nullable, defaultValue) {
 		readOnly: schema.readOnly,
 		writeOnly: schema.writeOnly,
 		default: defaultValue,
-		example: schema.example
+		example: schema.example,
+		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 +1510,44 @@ 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) {
+	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);
+		}
+	}
+	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 +1561,32 @@ function normalizeArrayEnum(schema) {
 	};
 }
 /**
+* 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 +1594,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 +1611,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.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 +1643,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,
@@ -1228,21 +1659,22 @@ function createSchemaParser(ctx) {
 				writeOnly: schema.writeOnly ?? memberNode.writeOnly,
 				default: mergedDefault,
 				example: schema.example ?? memberNode.example,
-				pattern: schema.pattern ?? ("pattern" in memberNode ? memberNode.pattern : void 0)
+				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.isReference(item) || !name) return true;
+			const deref = dialect.resolveRef(document, item.$ref);
+			if (!deref || !dialect.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.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 +1682,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.isReference(item)) return [item];
+					const deref = dialect.resolveRef(document, item.$ref);
+					return deref && !dialect.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 +1712,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,7 +1729,7 @@ 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]
@@ -1301,10 +1739,10 @@ function createSchemaParser(ctx) {
 		const strategy = schema.oneOf ? "one" : "any";
 		const unionBase = {
 			...buildSchemaNode(schema, name, nullable, defaultValue),
-			discriminatorPropertyName: isDiscriminator(schema) ? schema.discriminator.propertyName : void 0,
+			discriminatorPropertyName: dialect.isDiscriminator(schema) ? schema.discriminator.propertyName : void 0,
 			strategy
 		};
-		const discriminator = isDiscriminator(schema) ? schema.discriminator : void 0;
+		const discriminator = dialect.isDiscriminator(schema) ? schema.discriminator : void 0;
 		const sharedPropertiesNode = schema.properties ? (() => {
 			const { oneOf: _oneOf, anyOf: _anyOf, ...schemaWithoutUnion } = schema;
 			return parseSchema({
@@ -1314,56 +1752,63 @@ function createSchemaParser(ctx) {
 		})() : void 0;
 		if (sharedPropertiesNode || discriminator?.mapping) {
 			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.isReference(s) ? s.$ref : void 0;
+				const discriminatorValue = findDiscriminator(discriminator?.mapping, ref);
+				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({
+		if (constValue === null) return ast.factory.createSchema({
 			type: "null",
 			primitive: "null",
 			name,
 			title: schema.title,
 			description: schema.description,
-			deprecated: schema.deprecated
+			deprecated: schema.deprecated,
+			format: schema.format
 		});
 		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 +1821,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 +1833,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 +1850,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 +1895,15 @@ 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 ast.factory.createSchema({
+			type: "null",
+			primitive: "null",
+			name,
+			title: schema.title,
+			description: schema.description,
+			deprecated: schema.deprecated,
+			format: schema.format
+		});
 		const enumNullable = nullable || nullInEnum || void 0;
 		const enumDefault = schema.default === null && enumNullable ? void 0 : schema.default;
 		const enumPrimitive = getPrimitiveType(type);
@@ -1464,7 +1918,8 @@ function createSchemaParser(ctx) {
 			readOnly: schema.readOnly,
 			writeOnly: schema.writeOnly,
 			default: enumDefault,
-			example: schema.example
+			example: schema.example,
+			format: schema.format
 		};
 		const extensionKey = enumExtensionKeys.find((key) => key in schema);
 		if (extensionKey || enumPrimitive === "number" || enumPrimitive === "integer" || enumPrimitive === "boolean") {
@@ -1472,7 +1927,7 @@ function createSchemaParser(ctx) {
 			const rawEnumNames = extensionKey ? schema[extensionKey] : 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) => ({
@@ -1486,7 +1941,7 @@ function createSchemaParser(ctx) {
 				})
 			});
 		}
-		return ast.createSchema({
+		return ast.factory.createSchema({
 			...enumBase,
 			enumValues: [...new Set(filteredValues)]
 		});
@@ -1498,21 +1953,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.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 +1972,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: typeOptionMap.get(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: typeOptionMap.get(options.unknownType) }) : parseSchema({ schema: patternSchema }, rawOptions)])) : void 0;
+		const objectNode = ast.factory.createSchema({
 			type: "object",
 			primitive: "object",
 			properties,
@@ -1539,16 +1990,15 @@ function createSchemaParser(ctx) {
 			maxProperties: schema.maxProperties,
 			...buildSchemaNode(schema, name, nullable, defaultValue)
 		});
-		if (isDiscriminator(schema) && schema.discriminator.mapping) {
+		if (dialect.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 +2007,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 ? parseSchema({ schema: schema.items }, rawOptions) : ast.factory.createSchema({ type: "any" });
+		return ast.factory.createSchema({
 			type: "tuple",
 			primitive: "array",
 			items: tupleItems,
@@ -1573,12 +2023,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 +2042,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 +2055,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,7 +2070,7 @@ 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)
@@ -1630,22 +2080,155 @@ function createSchemaParser(ctx) {
 	* Converts an explicit `type: 'null'` schema.
 	*/
 	function convertNull({ schema, name, nullable }) {
-		return ast.createSchema({
+		return ast.factory.createSchema({
 			type: "null",
 			primitive: "null",
 			name,
 			title: schema.title,
 			description: schema.description,
 			deprecated: schema.deprecated,
-			nullable
+			nullable,
+			format: schema.format
+		});
+	}
+	/**
+	* Converts a binary string schema (`type: 'string'`, `contentMediaType: 'application/octet-stream'`)
+	* into a `blob` node.
+	*/
+	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 = [
+		{
+			name: "ref",
+			match: ({ schema }) => dialect.isReference(schema),
+			convert: convertRef
+		},
+		{
+			name: "allOf",
+			match: ({ schema }) => !!schema.allOf?.length,
+			convert: convertAllOf
+		},
+		{
+			name: "union",
+			match: ({ schema }) => !!(schema.oneOf?.length || schema.anyOf?.length),
+			convert: convertUnion
+		},
+		{
+			name: "const",
+			match: ({ schema }) => "const" in schema && schema.const !== void 0,
+			convert: convertConst
+		},
+		{
+			name: "format",
+			match: ({ schema }) => !!schema.format,
+			convert: convertFormat
+		},
+		{
+			name: "blob",
+			match: ({ schema }) => dialect.isBinary(schema),
+			convert: convertBlob
+		},
+		{
+			name: "multi-type",
+			match: ({ schema }) => Array.isArray(schema.type) && schema.type.length > 1,
+			convert: convertMultiType
+		},
+		{
+			name: "constrained-string",
+			match: ({ schema, type }) => !type && (schema.minLength !== void 0 || schema.maxLength !== void 0 || schema.pattern !== void 0),
+			convert: convertString
+		},
+		{
+			name: "constrained-number",
+			match: ({ schema, type }) => !type && (schema.minimum !== void 0 || schema.maximum !== void 0),
+			convert: (ctx) => convertNumeric(ctx, "number")
+		},
+		{
+			name: "enum",
+			match: ({ schema }) => !!schema.enum?.length,
+			convert: convertEnum
+		},
+		{
+			name: "object",
+			match: ({ schema, type }) => type === "object" || !!schema.properties || !!schema.additionalProperties || "patternProperties" in schema,
+			convert: convertObject
+		},
+		{
+			name: "tuple",
+			match: ({ schema }) => "prefixItems" in schema,
+			convert: convertTuple
+		},
+		{
+			name: "array",
+			match: ({ schema, type }) => type === "array" || "items" in schema,
+			convert: convertArray
+		},
+		{
+			name: "string",
+			match: ({ type }) => type === "string",
+			convert: convertString
+		},
+		{
+			name: "number",
+			match: ({ type }) => type === "number",
+			convert: (ctx) => convertNumeric(ctx, "number")
+		},
+		{
+			name: "integer",
+			match: ({ type }) => type === "integer",
+			convert: (ctx) => convertNumeric(ctx, "integer")
+		},
+		{
+			name: "boolean",
+			match: ({ type }) => type === "boolean",
+			convert: convertBoolean
+		},
+		{
+			name: "null",
+			match: ({ type }) => type === "null",
+			convert: convertNull
+		}
+	];
+	/**
+	* 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,75 +2240,43 @@ 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.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)
-			});
+		for (const rule of schemaRules) {
+			if (!rule.match(schemaCtx)) continue;
+			const node = rule.convert(schemaCtx);
+			if (node) return node;
 		}
-		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");
-		}
-		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({
+		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: typeOptionMap.get(options.unknownType) });
+		return ast.factory.createParameter({
+			name: paramName,
 			in: param["in"],
 			schema: {
 				...schema,
@@ -1762,27 +2313,33 @@ function createSchemaParser(ctx) {
 	* `$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.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 [{
 				contentType: ct,
-				schema: ast.syncOptionality(parseSchema({ schema }, options), requestBodyMeta.required),
+				schema: ast.syncOptionality(parseSchema({
+					schema,
+					name: requestBodyName
+				}, options), requestBodyMeta.required),
 				keysToOmit: collectPropertyKeysByFlag(schema, "readOnly")
 			}];
 		});
@@ -1791,29 +2348,58 @@ function createSchemaParser(ctx) {
 			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 } = getResponseMeta(responseObj);
+			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: typeOptionMap.get(options.emptySchemaType) }),
+					keysToOmit: collectPropertyKeysByFlag(raw, "writeOnly")
+				};
+			};
+			const content = (ctx.contentType ? [ctx.contentType] : getResponseBodyContentTypes(document, operation, statusCode)).map((contentType) => ({
+				contentType,
+				...parseEntrySchema(contentType)
+			}));
+			if (content.length === 0) content.push({
+				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.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 +2411,263 @@ function createSchemaParser(ctx) {
 		parseParameter
 	};
 }
+//#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
+/**
+* Builds the deduplication plan from the already-parsed top-level schema nodes plus a
+* single extra parse pass over operations (so duplicates in request/response bodies are seen).
+*
+* Only enums and objects are candidates, and object shapes that reference a circular schema are
+* rejected to avoid hoisting recursive structures. Inline shapes reuse their context-derived
+* name (collision-resolved against existing component names). Shapes without a name stay inline.
+*/
+function createDedupePlan({ schemaNodes, operationNodes, schemaNames, circularNames }) {
+	const circularSchemas = new Set(circularNames);
+	const usedNames = new Set(schemaNames);
+	return ast.buildDedupePlan([...schemaNodes, ...operationNodes], {
+		isCandidate: (node) => {
+			if (node.type === "enum") return true;
+			if (node.type !== "object") return false;
+			if (node.name && circularSchemas.has(node.name)) return false;
+			return !containsCircularRef(node, { circularSchemas });
+		},
+		nameFor: (node) => {
+			const base = node.name;
+			if (!base) return null;
+			let name = base;
+			let counter = 2;
+			while (usedNames.has(name)) name = `${base}${counter++}`;
+			usedNames.add(name);
+			return name;
+		},
+		refFor: (name) => `${SCHEMA_REF_PREFIX}${name}`
+	});
+}
+/**
+* Reads the server URL from the document's `servers` array at `serverIndex`,
+* interpolating any `serverVariables` into the URL template.
+*
+* Returns `null` when `serverIndex` is omitted or out of range.
+*
+* @example Resolve the first server
+* `resolveBaseUrl({ document, serverIndex: 0 })`
+*
+* @example Override a path variable
+* `resolveBaseUrl({ document, serverIndex: 0, serverVariables: { version: 'v2' } })`
+*/
+function resolveBaseUrl({ document, serverIndex, serverVariables }) {
+	const server = serverIndex !== void 0 ? document.servers?.at(serverIndex) : void 0;
+	return server?.url ? resolveServerUrl(server, serverVariables) : 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 { refAliasMap, enumNames, circularNames } = preScan({
+*   schemas,
+*   parseSchema,
+*   parserOptions,
+*   discriminator: 'strict',
+* })
+* ```
+*/
+function preScan({ schemas, parseSchema, parseOperation, document, parserOptions, discriminator, dedupe }) {
+	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);
+		if (ast.narrowSchema(node, ast.schemaTypes.enum) && node.name) enumNames.push(node.name);
+		if (discriminator === "inherit" && (schema.oneOf ?? schema.anyOf) && schema.discriminator?.propertyName) discriminatorParentNodes.push(node);
+	}
+	const circularNames = [...findCircularSchemas(allNodes)];
+	const discriminatorChildMap = discriminatorParentNodes.length > 0 ? buildDiscriminatorChildMap(discriminatorParentNodes) : null;
+	let dedupePlan = null;
+	if (dedupe) {
+		const operationNodes = [];
+		for (const operation of getOperations(document)) {
+			const operationNode = parseOperation(parserOptions, operation);
+			if (operationNode) operationNodes.push(operationNode);
+		}
+		dedupePlan = createDedupePlan({
+			schemaNodes: allNodes,
+			operationNodes,
+			schemaNames: Object.keys(schemas),
+			circularNames
+		});
+		for (const definition of dedupePlan.hoisted) if (definition.type === "enum" && definition.name) enumNames.push(definition.name);
+	}
+	const aliasNames = dedupePlan?.aliasNames;
+	return {
+		refAliasMap,
+		enumNames: aliasNames && aliasNames.size > 0 ? enumNames.filter((name) => !aliasNames.has(name)) : enumNames,
+		circularNames,
+		discriminatorChildMap,
+		dedupePlan
+	};
+}
+/**
+* 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.
 *
-* const document = await parseFromConfig(config)
-* const { root, nameMapping } = parseOas(document, { dateType: 'date', contentType: 'application/json' })
+* 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 parseOas(document, options = {}) {
-	const { contentType, ...parserOptions } = options;
-	const mergedOptions = {
-		...DEFAULT_PARSER_OPTIONS,
-		...parserOptions
+function createInputStream({ schemas, parseSchema, parseOperation, document, parserOptions, refAliasMap, discriminatorChildMap, dedupePlan, meta }) {
+	const rewriteTopLevelSchema = (node) => {
+		if (!dedupePlan) return node;
+		const canonical = dedupePlan.canonicalBySignature.get(ast.signatureOf(node));
+		if (canonical && canonical.name !== node.name) return ast.factory.createSchema({
+			type: "ref",
+			name: node.name ?? null,
+			ref: canonical.ref,
+			description: node.description,
+			deprecated: node.deprecated
+		});
+		return ast.applyDedupe(node, dedupePlan, true);
 	};
-	const { schemas: schemaObjects, nameMapping } = getSchemas(document, { contentType });
-	const { parseSchema: _parseSchema, parseOperation: _parseOperation } = createSchemaParser({
-		document,
-		contentType
+	const schemasIterable = { [Symbol.asyncIterator]() {
+		return (async function* () {
+			if (dedupePlan) for (const definition of dedupePlan.hoisted) yield definition;
+			for (const [name, schema] of Object.entries(schemas)) {
+				if (dedupePlan?.aliasNames.has(name)) continue;
+				const alias = refAliasMap.get(name);
+				if (alias?.name && schemas[alias.name]) {
+					yield rewriteTopLevelSchema({
+						...parseSchema({
+							schema: schemas[alias.name],
+							name: alias.name
+						}, parserOptions),
+						name
+					});
+					continue;
+				}
+				const parsed = parseSchema({
+					schema,
+					name
+				}, parserOptions);
+				yield rewriteTopLevelSchema(discriminatorChildMap?.get(name) ? patchDiscriminatorNode(parsed, discriminatorChildMap.get(name)) : parsed);
+			}
+		})();
+	} };
+	const operationsIterable = { [Symbol.asyncIterator]() {
+		return (async function* () {
+			for (const operation of getOperations(document)) {
+				const node = parseOperation(parserOptions, operation);
+				if (node) yield dedupePlan ? ast.applyDedupe(node, dedupePlan) : node;
+			}
+		})();
+	} };
+	return ast.factory.createInput({
+		stream: true,
+		schemas: schemasIterable,
+		operations: operationsIterable,
+		meta
 	});
-	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));
-	return {
-		root: ast.createInput({
-			schemas,
-			operations
-		}),
-		nameMapping
-	};
 }
 //#endregion
 //#region src/adapter.ts
 /**
-* Stable string identifier for the OAS adapter used in Kubb's adapter registry.
+* Canonical adapter name for `@kubb/adapter-oas`. Used for driver lookups.
 */
 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,17 +2676,109 @@ 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({
+*     serverIndex: 0,
+*     discriminator: 'inherit',
+*     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, serverIndex, serverVariables, discriminator = "strict", dedupe = true, 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,
+			dedupe
+		});
+		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, dedupePlan } = ensurePreScan(document, schemas, parseSchema, parseOperation);
+		return createInputStream({
+			schemas,
+			parseSchema,
+			parseOperation,
+			document,
+			parserOptions,
+			refAliasMap,
+			discriminatorChildMap,
+			dedupePlan,
+			meta: {
+				title: document.info?.title,
+				description: document.info?.description,
+				version: document.info?.version,
+				baseURL: resolveBaseUrl({
+					document,
+					serverIndex,
+					serverVariables
+				}),
+				circularNames,
+				enumNames
+			}
+		});
+	}
 	return {
 		name: "oas",
 		get options() {
@@ -1906,6 +2788,7 @@ const adapterOas = createAdapter((options) => {
 				serverIndex,
 				serverVariables,
 				discriminator,
+				dedupe,
 				dateType,
 				integerType,
 				unknownType,
@@ -1917,68 +2800,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 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
-				}
+			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
 			});
-			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 };
+export { adapterOas, adapterOasName };
 
 //# sourceMappingURL=index.js.map