@kubb/adapter-oas 5.0.0-beta.53 → 5.0.0-beta.55

package/dist/index.js

@@ -1,14 +1,12 @@
 import "./chunk-C0LytTxp.js";
 import { Diagnostics, ast, createAdapter } from "@kubb/core";
-import BaseOas from "oas";
 import path from "node:path";
 import { access, readFile } from "node:fs/promises";
-import OASNormalize from "oas-normalize";
+import { compileErrors, validate } from "@readme/openapi-parser";
+import { parse } from "yaml";
 import { bundle } from "api-ref-bundler";
-import yaml from "js-yaml";
 import { childName, enumPropName, extractRefName, findDiscriminator } from "@kubb/ast/utils";
-import { isRef } from "oas/types";
-import { matchesMimeType } from "oas/utils";
+import { collect, narrowSchema } from "@kubb/ast";
 //#region src/constants.ts
 /**
 * Default parser options applied when no explicit options are provided.
@@ -40,6 +38,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";
@@ -152,77 +164,103 @@ const typeOptionMap = new Map([
 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("/");
-}
-/**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
-*
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
-*/
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 /**
 * Converts `text` to PascalCase.
-* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
 *
-* @example
-* pascalCase('hello-world')                  // 'HelloWorld'
-* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
-*/
-function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
-		prefix,
-		suffix
-	}) : camelCase(part));
+* @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
 /**
-* Returns `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.
+* Detects the JavaScript runtime executing the current process and exposes its name and version.
 *
-* @example
-* ```ts
-* if (isBun()) {
-*   await Bun.write(path, data)
-* }
-* ```
+* Prefer the shared {@link runtime} instance over constructing your own.
 */
-function isBun() {
-	return typeof Bun !== "undefined";
-}
+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
 /**
@@ -237,7 +275,7 @@ function isBun() {
 * ```
 */
 async function exists(path) {
-	if (isBun()) return Bun.file(path).exists();
+	if (runtime.isBun) return Bun.file(path).exists();
 	return access(path).then(() => true, () => false);
 }
 /**
@@ -250,7 +288,7 @@ async function exists(path) {
 * ```
 */
 async function read(path) {
-	if (isBun()) return Bun.file(path).text();
+	if (runtime.isBun) return Bun.file(path).text();
 	return readFile(path, { encoding: "utf8" });
 }
 //#endregion
@@ -407,99 +445,80 @@ function isIdentifier(name) {
 	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
 //#endregion
-//#region ../../internals/utils/src/urlPath.ts
+//#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;
+	}
+	return Object.keys(params).length > 0 ? params : null;
+}
 /**
-* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
-*
-* @example
-* const p = new URLPath('/pet/{petId}')
-* p.URL      // '/pet/:petId'
-* p.template // '`/pet/${petId}`'
+* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
 */
-var URLPath = class {
+var Url = class Url {
 	/**
-	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
-	*/
-	path;
-	#options;
-	constructor(path, options = {}) {
-		this.path = path;
-		this.#options = options;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+	* 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(`"`, "");
@@ -508,50 +527,6 @@ 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 } = {}) {
-		const result = this.path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = this.#transformParam(part);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("");
-		return `\`${prefix ?? ""}${result}\``;
-	}
-	/**
-	* 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
@@ -568,7 +543,7 @@ async function readSource(sourcePath) {
 async function resolveSource(sourcePath) {
 	const data = await readSource(sourcePath);
 	if (sourcePath.toLowerCase().endsWith(".md")) return data;
-	return yaml.load(data);
+	return parse(data);
 }
 /**
 * Bundles a multi-file OpenAPI document into a single document via `api-ref-bundler`.
@@ -673,15 +648,9 @@ 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 bundleDocument(pathOrApi), {
-		canBundle: false,
-		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 });
@@ -692,7 +661,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
@@ -701,10 +670,7 @@ async function parseDocument(pathOrApi, { canBundle = true, enablePaths = true }
 * ```
 */
 async function mergeDocuments(pathOrApi) {
-	const documents = await Promise.all(pathOrApi.map((p) => parseDocument(p, {
-		enablePaths: false,
-		canBundle: false
-	})));
+	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",
@@ -743,7 +709,7 @@ async function parseFromConfig(source) {
 		return parseDocument(source.data, { canBundle: false });
 	}
 	if (source.type === "paths") return mergeDocuments(source.paths);
-	if (new URLPath(source.path).isURL) return parseDocument(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);
@@ -754,7 +720,7 @@ async function parseFromConfig(source) {
 * its parse error instead.
 */
 async function assertInputExists(input) {
-	if (new URLPath(input).isURL) return;
+	if (Url.canParse(input)) return;
 	if (!await exists(input)) throw new Diagnostics.Error({
 		code: Diagnostics.code.inputNotFound,
 		severity: "error",
@@ -764,7 +730,7 @@ async function assertInputExists(input) {
 	});
 }
 /**
-* Validates an OpenAPI document using `oas-normalize` with colorized error output.
+* Validates an OpenAPI document using `@readme/openapi-parser` with colorized error output.
 *
 * @example
 * ```ts
@@ -773,10 +739,8 @@ async function assertInputExists(input) {
 */
 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;
 	}
@@ -876,6 +840,161 @@ const oasDialect = ast.defineSchemaDialect({
 	resolveRef
 });
 //#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;
+}
+/**
+* Returns the request body media type. With `mediaType` set, returns that entry or `false`.
+* Otherwise picks the first JSON-like media type, then the first declared one, as a
+* `[mediaType, object]` tuple.
+*/
+function getRequestContent({ document, operation, mediaType }) {
+	const content = getRequestBodyContent({
+		document,
+		operation
+	});
+	if (!content) return false;
+	if (mediaType) return mediaType in content ? content[mediaType] : false;
+	const mediaTypes = Object.keys(content);
+	const available = mediaTypes.find((mt) => isJsonMimeType(mt)) ?? mediaTypes[0];
+	return available ? [available, content[available]] : false;
+}
+/**
+* Returns the primary request content type. Prefers a JSON-like media type (the last one wins,
+* 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
+* for (const operation of getOperations(document)) {
+*   parseOperation(options, operation)
+* }
+* ```
+*/
+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
 /**
 * Replaces `{variable}` placeholders in an OpenAPI server URL with provided values.
@@ -968,7 +1087,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;
 	}
@@ -999,7 +1118,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 {};
@@ -1015,7 +1138,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;
@@ -1050,7 +1177,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;
@@ -1288,7 +1415,11 @@ function getResponseBodyContentTypes(document, operation, statusCode) {
 			if (schema && isReference(schema)) responses[key] = resolveRef(document, schema.$ref);
 		}
 	}
-	const responseObj = operation.getResponseByStatusCode(statusCode);
+	const responseObj = getResponseByStatusCode({
+		document,
+		operation,
+		statusCode
+	});
 	if (!responseObj || typeof responseObj !== "object" || isReference(responseObj)) return [];
 	const body = responseObj;
 	return body.content ? Object.keys(body.content) : [];
@@ -1872,7 +2003,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 		});
 	}
 	/**
-	* Ordered schema-dispatch table. Order is significant: composition keywords (`$ref`, `allOf`,
+	* 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.
@@ -1970,10 +2101,10 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 		}
 	];
 	/**
-	* Central dispatcher that converts an OAS `SchemaObject` into a `SchemaNode`.
+	* Converts an OAS `SchemaObject` into a `SchemaNode`.
 	*
-	* Builds the per-schema context, then runs it through the ordered {@link schemaRules} table
-	* via {@link ast.dispatch}. When no rule produces a node, falls back to the configured
+	* 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) {
@@ -1996,8 +2127,11 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 			rawOptions,
 			options
 		};
-		const node = ast.dispatch(schemaRules, schemaCtx);
-		if (node) return node;
+		for (const rule of schemaRules) {
+			if (!rule.match(schemaCtx)) continue;
+			const node = rule.convert(schemaCtx);
+			if (node) return node;
+		}
 		const emptyType = typeOptionMap.get(options.emptySchemaType);
 		return ast.createSchema({
 			type: emptyType,
@@ -2068,7 +2202,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 	* Converts an OAS `Operation` into an `OperationNode`.
 	*/
 	function parseOperation(options, operation) {
-		const operationId = operation.getOperationId();
+		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);
@@ -2091,8 +2225,12 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 			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 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) => {
@@ -2110,7 +2248,10 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 				...parseEntrySchema(contentType)
 			}));
 			if (content.length === 0) content.push({
-				contentType: operation.contentType || "application/json",
+				contentType: getRequestContentType({
+					document,
+					operation
+				}) || "application/json",
 				...parseEntrySchema(ctx.contentType)
 			});
 			return ast.createResponse({
@@ -2119,16 +2260,23 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 				content
 			});
 		});
-		const urlPath = new URLPath(operation.path);
+		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.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
@@ -2346,7 +2494,7 @@ function resolveBaseUrl({ document, serverIndex, serverVariables }) {
 * })
 * ```
 */
-function preScan({ schemas, parseSchema, parseOperation, baseOas, parserOptions, discriminator, dedupe }) {
+function preScan({ schemas, parseSchema, parseOperation, document, parserOptions, discriminator, dedupe }) {
 	const allNodes = [];
 	const refAliasMap = /* @__PURE__ */ new Map();
 	const enumNames = [];
@@ -2370,8 +2518,7 @@ function preScan({ schemas, parseSchema, parseOperation, baseOas, parserOptions,
 	let dedupePlan = null;
 	if (dedupe) {
 		const operationNodes = [];
-		for (const methods of Object.values(baseOas.getPaths())) for (const operation of Object.values(methods)) {
-			if (!operation) continue;
+		for (const operation of getOperations(document)) {
 			const operationNode = parseOperation(parserOptions, operation);
 			if (operationNode) operationNodes.push(operationNode);
 		}
@@ -2383,16 +2530,17 @@ function preScan({ schemas, parseSchema, parseOperation, baseOas, parserOptions,
 		});
 		for (const definition of dedupePlan.hoisted) if (definition.type === "enum" && definition.name) enumNames.push(definition.name);
 	}
+	const aliasNames = dedupePlan?.aliasNames;
 	return {
 		refAliasMap,
-		enumNames,
+		enumNames: aliasNames && aliasNames.size > 0 ? enumNames.filter((name) => !aliasNames.has(name)) : enumNames,
 		circularNames,
 		discriminatorChildMap,
 		dedupePlan
 	};
 }
 /**
-* Creates a lazy `InputStreamNode` from already-resolved adapter state.
+* 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
@@ -2403,16 +2551,16 @@ function preScan({ schemas, parseSchema, parseOperation, baseOas, parserOptions,
 *
 * @example
 * ```ts
-* const streamNode = createInputStream({ schemas, parseSchema, parseOperation, baseOas, parserOptions, refAliasMap, discriminatorChildMap, meta })
+* const streamNode = createInputStream({ schemas, parseSchema, parseOperation, document, parserOptions, refAliasMap, discriminatorChildMap, meta })
 * for await (const schema of streamNode.schemas) {
 *   // each call to for-await restarts from the first schema
 * }
 * ```
 */
-function createInputStream({ schemas, parseSchema, parseOperation, baseOas, parserOptions, refAliasMap, discriminatorChildMap, dedupePlan, meta }) {
+function createInputStream({ schemas, parseSchema, parseOperation, document, parserOptions, refAliasMap, discriminatorChildMap, dedupePlan, meta }) {
 	const rewriteTopLevelSchema = (node) => {
 		if (!dedupePlan) return node;
-		const canonical = dedupePlan.canonicalBySignature.get(ast.schemaSignature(node));
+		const canonical = dedupePlan.canonicalBySignature.get(ast.signatureOf(node));
 		if (canonical && canonical.name !== node.name) return ast.createSchema({
 			type: "ref",
 			name: node.name ?? null,
@@ -2420,12 +2568,13 @@ function createInputStream({ schemas, parseSchema, parseOperation, baseOas, pars
 			description: node.description,
 			deprecated: node.deprecated
 		});
-		return ast.applyDedupe(node, dedupePlan.canonicalBySignature, true);
+		return ast.applyDedupe(node, dedupePlan, true);
 	};
 	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({
@@ -2447,10 +2596,9 @@ function createInputStream({ schemas, parseSchema, parseOperation, baseOas, pars
 	} };
 	const operationsIterable = { [Symbol.asyncIterator]() {
 		return (async function* () {
-			for (const methods of Object.values(baseOas.getPaths())) for (const operation of Object.values(methods)) {
-				if (!operation) continue;
+			for (const operation of getOperations(document)) {
 				const node = parseOperation(parserOptions, operation);
-				if (node) yield dedupePlan ? ast.applyDedupe(node, dedupePlan.canonicalBySignature) : node;
+				if (node) yield dedupePlan ? ast.applyDedupe(node, dedupePlan) : node;
 			}
 		})();
 	} };
@@ -2503,7 +2651,6 @@ const adapterOas = createAdapter((options) => {
 	let parsedDocument = null;
 	const documentCache = /* @__PURE__ */ new WeakMap();
 	const schemasCache = /* @__PURE__ */ new WeakMap();
-	const baseOasCache = /* @__PURE__ */ new WeakMap();
 	const schemaParserCache = /* @__PURE__ */ new WeakMap();
 	const preScanCache = /* @__PURE__ */ new WeakMap();
 	function ensureDocument(source) {
@@ -2529,13 +2676,6 @@ const adapterOas = createAdapter((options) => {
 		schemasCache.set(document, promise);
 		return promise;
 	}
-	function ensureBaseOas(document) {
-		const cached = baseOasCache.get(document);
-		if (cached) return cached;
-		const baseOas = new BaseOas(document);
-		baseOasCache.set(document, baseOas);
-		return baseOas;
-	}
 	function ensureSchemaParser(document) {
 		const cached = schemaParserCache.get(document);
 		if (cached) return cached;
@@ -2546,14 +2686,14 @@ const adapterOas = createAdapter((options) => {
 		schemaParserCache.set(document, parser);
 		return parser;
 	}
-	function ensurePreScan(document, schemas, parseSchema, parseOperation, baseOas) {
+	function ensurePreScan(document, schemas, parseSchema, parseOperation) {
 		const cached = preScanCache.get(document);
 		if (cached) return cached;
 		const result = preScan({
 			schemas,
 			parseSchema,
 			parseOperation,
-			baseOas,
+			document,
 			parserOptions,
 			discriminator,
 			dedupe
@@ -2565,13 +2705,12 @@ const adapterOas = createAdapter((options) => {
 		const document = await ensureDocument(source);
 		const schemas = await ensureSchemas(document);
 		const { parseSchema, parseOperation } = ensureSchemaParser(document);
-		const baseOas = ensureBaseOas(document);
-		const { refAliasMap, enumNames, circularNames, discriminatorChildMap, dedupePlan } = ensurePreScan(document, schemas, parseSchema, parseOperation, baseOas);
+		const { refAliasMap, enumNames, circularNames, discriminatorChildMap, dedupePlan } = ensurePreScan(document, schemas, parseSchema, parseOperation);
 		return createInputStream({
 			schemas,
 			parseSchema,
 			parseOperation,
-			baseOas,
+			document,
 			parserOptions,
 			refAliasMap,
 			discriminatorChildMap,
@@ -2616,18 +2755,17 @@ const adapterOas = createAdapter((options) => {
 			await validateDocument(await parseDocument(input), options);
 		},
 		getImports(node, resolve) {
-			return ast.collectImports({
-				node,
-				nameMapping,
-				resolve: (schemaName) => {
-					const result = resolve(schemaName);
-					if (!result) return null;
-					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.createImport({
+					name: [result.name],
+					path: result.path
+				});
+			} });
 		},
 		async parse(source) {
 			const streamNode = await createStream(source);