@kubb/adapter-oas 4.36.1 → 5.0.0-alpha.10

package/dist/index.cjs

@@ -289,9 +289,8 @@ const formatMap = {
 };
 /**
 * Exhaustive list of media types that Kubb recognizes.
-* Kept as a module-level constant to avoid re-allocating the array on every call.
 */
-const knownMediaTypes = [
+const knownMediaTypes = new Set([
 	"application/json",
 	"application/xml",
 	"application/x-www-form-urlencoded",
@@ -311,12 +310,22 @@ const knownMediaTypes = [
 	"image/svg+xml",
 	"audio/mpeg",
 	"video/mp4"
-];
+]);
 /**
 * Vendor extension keys used to attach human-readable labels to enum values.
 * Checked in priority order: the first key found wins.
 */
 const enumExtensionKeys = ["x-enumNames", "x-enum-varnames"];
+/**
+* Scalar primitive schema types used for union member simplification.
+*/
+const SCALAR_PRIMITIVE_TYPES = new Set([
+	"string",
+	"number",
+	"integer",
+	"bigint",
+	"boolean"
+]);
 //#endregion
 //#region src/oas/Oas.ts
 /**
@@ -529,8 +538,15 @@ var Oas = class extends oas.default {
 		if (!schema) return;
 		return this.dereferenceWithRef(schema);
 	}
-	getParametersSchema(operation, inKey) {
-		const { contentType = operation.getContentType() } = this.#options;
+	/**
+	* Returns all resolved parameters for an operation, merging path-level and operation-level
+	* parameters and deduplicating by `in:name` (operation-level takes precedence).
+	*
+	* oas v31+ filters out `$ref` parameters in `getParameters()`, so this method accesses the
+	* raw `operation.schema.parameters` and path-item parameters directly and resolves `$ref`
+	* pointers via `dereferenceWithRef` to preserve backward compatibility.
+	*/
+	getParameters(operation) {
 		const resolveParams = (params) => params.map((p) => this.dereferenceWithRef(p)).filter((p) => !!p && typeof p === "object" && "in" in p && "name" in p);
 		const operationParams = resolveParams(operation.schema?.parameters || []);
 		const pathItem = this.api?.paths?.[operation.path];
@@ -538,7 +554,11 @@ var Oas = class extends oas.default {
 		const paramMap = /* @__PURE__ */ new Map();
 		for (const p of pathLevelParams) if (p.name && p.in) paramMap.set(`${p.in}:${p.name}`, p);
 		for (const p of operationParams) if (p.name && p.in) paramMap.set(`${p.in}:${p.name}`, p);
-		const params = Array.from(paramMap.values()).filter((v) => v.in === inKey);
+		return Array.from(paramMap.values());
+	}
+	getParametersSchema(operation, inKey) {
+		const { contentType = operation.getContentType() } = this.#options;
+		const params = this.getParameters(operation).filter((v) => v.in === inKey);
 		if (!params.length) return null;
 		return params.reduce((schema, pathParameters) => {
 			const property = pathParameters.content?.[contentType]?.schema ?? pathParameters.schema;
@@ -928,6 +948,136 @@ function resolveCollisions(schemasWithMeta) {
 	};
 }
 //#endregion
+//#region src/utils.ts
+/**
+* Extracts the schema name from a `$ref` string.
+* For `#/components/schemas/Order` this returns `'Order'`.
+* Falls back to the full ref string when no slash is present.
+*/
+function extractRefName($ref) {
+	return $ref.split("/").at(-1) ?? $ref;
+}
+/**
+* Replaces the discriminator property's schema inside an `ObjectSchemaNode`
+* with an enum of the given `values`.
+*
+* - When `enumName` is provided the enum is named, which lets printers emit a
+*   standalone enum declaration + type reference (e.g. `PetTypeEnum`).
+* - When `enumName` is omitted the enum stays anonymous, so printers inline it
+*   as a literal union (e.g. `'dog'`).
+*
+* Returns the node unchanged when it is not an object or lacks the target property.
+*/
+function applyDiscriminatorEnum({ node, propertyName, values, enumName }) {
+	if (node.type !== "object" || !node.properties?.length) return node;
+	if (!node.properties.some((prop) => prop.name === propertyName)) return node;
+	return (0, _kubb_ast.createSchema)({
+		...node,
+		properties: node.properties.map((prop) => {
+			if (prop.name !== propertyName) return prop;
+			const enumSchema = (0, _kubb_ast.createSchema)({
+				type: "enum",
+				primitive: "string",
+				enumValues: values,
+				name: enumName,
+				readOnly: prop.schema.readOnly,
+				writeOnly: prop.schema.writeOnly
+			});
+			return (0, _kubb_ast.createProperty)({
+				...prop,
+				schema: enumSchema
+			});
+		})
+	});
+}
+/**
+* Merges consecutive anonymous (`name`-less) `ObjectSchemaNode`s in `members` into a
+* single object by combining their `properties` arrays.
+*
+* Only adjacent pairs are merged — non-object or named nodes act as boundaries.
+* This collapses patterns like `Address & { streetNumber } & { streetName }` into
+* `Address & { streetNumber; streetName }`.
+*/
+function mergeAdjacentAnonymousObjects(members) {
+	return members.reduce((acc, member) => {
+		const obj = (0, _kubb_ast.narrowSchema)(member, "object");
+		if (obj && !obj.name) {
+			const prev = acc[acc.length - 1];
+			const prevObj = prev ? (0, _kubb_ast.narrowSchema)(prev, "object") : null;
+			if (prevObj && !prevObj.name) {
+				acc[acc.length - 1] = (0, _kubb_ast.createSchema)({
+					...prevObj,
+					properties: [...prevObj.properties ?? [], ...obj.properties ?? []]
+				});
+				return acc;
+			}
+		}
+		acc.push(member);
+		return acc;
+	}, []);
+}
+/**
+* Simplifies a union member list by removing `enum` nodes whose `primitive` type is
+* already represented by a broader scalar node in the same union.
+*
+* For example `['placed', 'approved'] | string` collapses to `string` because
+* `string` subsumes all string literals.  `'' | string` similarly becomes `string`.
+*
+* Only scalar primitives (`string`, `number`, `integer`, `bigint`, `boolean`) are
+* considered — object, array, and ref members are left untouched.
+*
+* Const-derived enums (those without an `enumType`, produced from an OpenAPI `const`
+* keyword) are **never** removed — `'accepted' | string` must stay as-is because the
+* literal is intentional.
+*/
+function simplifyUnionMembers(members) {
+	const scalarPrimitives = new Set(members.filter((m) => SCALAR_PRIMITIVE_TYPES.has(m.type)).map((m) => m.type));
+	if (!scalarPrimitives.size) return members;
+	return members.filter((m) => {
+		if (m.type !== "enum") return true;
+		const prim = m.primitive;
+		if (!prim) return true;
+		if (!m.enumType) return true;
+		if (scalarPrimitives.has(prim)) return false;
+		if ((prim === "integer" || prim === "number") && (scalarPrimitives.has("integer") || scalarPrimitives.has("number"))) return false;
+		return true;
+	});
+}
+/**
+* `nameMapping`, and calls `resolve` to obtain the `{ name, path }` pair for
+* each import. When `oas` is supplied, only `$ref`s that are resolvable in the
+* spec are included; omit it to skip the existence check.
+*
+* This function is the pure, state-free alternative to `OasParser.getImports`.
+* Because it receives `nameMapping` explicitly it can be called without holding
+* a reference to the parser or the OAS instance.
+*
+* @example
+* ```ts
+* // Use adapter state directly — no parser reference needed
+* const imports = getImports({
+*   node: schemaNode,
+*   nameMapping: adapter.options.nameMapping,
+*   resolve: (schemaName) => ({
+*     name: schemaManager.getName(schemaName, { type: 'type' }),
+*     path: schemaManager.getFile(schemaName).path,
+*   }),
+* })
+* ```
+*/
+function getImports({ node, nameMapping, resolve }) {
+	return (0, _kubb_ast.collect)(node, { schema(schemaNode) {
+		if (schemaNode.type !== "ref" || !schemaNode.ref) return;
+		const rawName = extractRefName(schemaNode.ref);
+		const result = resolve(nameMapping.get(rawName) ?? rawName);
+		if (!result) return;
+		return {
+			name: [result.name],
+			path: result.path
+		};
+	} });
+}
+//#endregion
 //#region src/parser.ts
 /**
 * Default values for all `Options` fields.
@@ -948,14 +1098,6 @@ function formatToSchemaType(format) {
 	return formatMap[format];
 }
 /**
-* Extracts the final path segment of a JSON Pointer `$ref` string.
-* For `#/components/schemas/Order` this returns `'Order'`.
-* Falls back to the full ref string when no slash is present.
-*/
-function extractRefName($ref) {
-	return $ref.split("/").at(-1) ?? $ref;
-}
-/**
 * Maps an OAS primitive type string to its `PrimitiveSchemaType` equivalent.
 * Numeric types (`number`, `integer`, `bigint`) are returned unchanged;
 * `boolean` maps to `'boolean'`; everything else defaults to `'string'`.
@@ -970,27 +1112,7 @@ function getPrimitiveType(type) {
 * Returns `undefined` for content types not present in `KNOWN_MEDIA_TYPES`.
 */
 function toMediaType(contentType) {
-	return knownMediaTypes.includes(contentType) ? contentType : void 0;
-}
-/**
-* When a discriminator is present, replaces the discriminator property's schema with
-* an enum of the mapping keys so downstream code emits a precise literal-union type.
-* Returns the original schema unchanged when there is no discriminator or no mapping.
-*/
-function applyDiscriminatorEnum(schema) {
-	if (!isDiscriminator(schema)) return schema;
-	const propName = schema.discriminator.propertyName;
-	if (!schema.properties?.[propName]) return schema;
-	return {
-		...schema,
-		properties: {
-			...schema.properties,
-			[propName]: {
-				...schema.properties[propName],
-				enum: schema.discriminator.mapping ? Object.keys(schema.discriminator.mapping) : void 0
-			}
-		}
-	};
+	return knownMediaTypes.has(contentType) ? contentType : void 0;
 }
 /**
 * Creates an OAS parser that converts an OpenAPI/Swagger spec into
@@ -1083,18 +1205,17 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* reflected in generated JSDoc and type modifiers.
 	*/
 	function convertRef({ schema, nullable, defaultValue }) {
-		const schemaObject = schema;
 		return (0, _kubb_ast.createSchema)({
 			type: "ref",
-			name: extractRefName(schemaObject.$ref),
-			ref: schemaObject.$ref,
+			name: extractRefName(schema.$ref),
+			ref: schema.$ref,
 			nullable,
-			description: schemaObject.description,
-			deprecated: schemaObject.deprecated,
-			readOnly: schemaObject.readOnly,
-			writeOnly: schemaObject.writeOnly,
-			pattern: schemaObject.type === "string" ? schemaObject.pattern : void 0,
-			example: schemaObject.example,
+			description: schema.description,
+			deprecated: schema.deprecated,
+			readOnly: schema.readOnly,
+			writeOnly: schema.writeOnly,
+			pattern: schema.type === "string" ? schema.pattern : void 0,
+			example: schema.example,
 			default: defaultValue
 		});
 	}
@@ -1145,6 +1266,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			const inMapping = Object.values(deref.discriminator.mapping ?? {}).some((v) => v === childRef);
 			return !inOneOf && !inMapping;
 		}).map((s) => convertSchema({ schema: s }, options));
+		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));
@@ -1169,7 +1291,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 		}
 		return (0, _kubb_ast.createSchema)({
 			type: "intersection",
-			members: allOfMembers,
+			members: [...allOfMembers.slice(0, syntheticStart), ...mergeAdjacentAnonymousObjects(allOfMembers.slice(syntheticStart))],
 			...buildSchemaBase(schema, name, nullable, defaultValue)
 		});
 	}
@@ -1189,20 +1311,34 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 		};
 		if (schema.properties) {
 			const { oneOf: _oneOf, anyOf: _anyOf, ...schemaWithoutUnion } = schema;
-			const propertiesNode = convertSchema({ schema: schemaWithoutUnion }, options);
+			const discriminator = isDiscriminator(schema) ? schema.discriminator : void 0;
+			const memberBaseSchema = discriminator ? Object.fromEntries(Object.entries(schemaWithoutUnion).filter(([key]) => key !== "discriminator")) : schemaWithoutUnion;
 			return (0, _kubb_ast.createSchema)({
 				type: "union",
 				...unionBase,
-				members: unionMembers.map((s) => (0, _kubb_ast.createSchema)({
-					type: "intersection",
-					members: [convertSchema({ schema: s }, options), propertiesNode]
-				}))
+				members: unionMembers.map((s) => {
+					const ref = isReference(s) ? s.$ref : void 0;
+					const discriminatorValue = discriminator?.mapping && ref ? Object.entries(discriminator.mapping).find(([, v]) => v === ref)?.[0] : void 0;
+					let propertiesNode = convertSchema({
+						schema: memberBaseSchema,
+						name
+					}, options);
+					if (discriminatorValue && discriminator) propertiesNode = applyDiscriminatorEnum({
+						node: propertiesNode,
+						propertyName: discriminator.propertyName,
+						values: [discriminatorValue]
+					});
+					return (0, _kubb_ast.createSchema)({
+						type: "intersection",
+						members: [convertSchema({ schema: s }, options), propertiesNode]
+					});
+				})
 			});
 		}
 		return (0, _kubb_ast.createSchema)({
 			type: "union",
 			...unionBase,
-			members: unionMembers.map((s) => convertSchema({ schema: s }, options))
+			members: simplifyUnionMembers(unionMembers.map((s) => convertSchema({ schema: s }, options)))
 		});
 	}
 	/**
@@ -1269,6 +1405,11 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			primitive: specialPrimitive,
 			type: specialType
 		});
+		if (specialType === "url") return (0, _kubb_ast.createSchema)({
+			...base,
+			primitive: "string",
+			type: "url"
+		});
 		return (0, _kubb_ast.createSchema)({
 			...base,
 			primitive: specialPrimitive,
@@ -1287,9 +1428,8 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	*/
 	function convertEnum({ schema, name, nullable, type, options }) {
 		if (type === "array") {
-			const rawSchema = schema;
 			const normalizedItems = {
-				...typeof rawSchema.items === "object" && !Array.isArray(rawSchema.items) ? rawSchema.items : {},
+				...typeof schema.items === "object" && !Array.isArray(schema.items) ? schema.items : {},
 				enum: schema.enum
 			};
 			const { enum: _enum, ...schemaWithoutEnum } = schema;
@@ -1369,22 +1509,28 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* - not required + nullable → `nullish: true`
 	*/
 	function convertObject({ schema, name, nullable, defaultValue, options, mergedOptions }) {
-		const resolvedSchema = applyDiscriminatorEnum(schema);
-		const properties = resolvedSchema.properties ? Object.entries(resolvedSchema.properties).map(([propName, propSchema]) => {
-			const required = Array.isArray(resolvedSchema.required) ? resolvedSchema.required.includes(propName) : !!resolvedSchema.required;
+		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 basePropName = name ? pascalCase([name, propName].join(" ")) : void 0;
+			const propNode = convertSchema({
+				schema: resolvedPropSchema,
+				name: basePropName
+			}, options);
+			const isEnumNode = !!(0, _kubb_ast.narrowSchema)(propNode, "enum");
+			const derivedPropName = isEnumNode && name ? pascalCase([
+				name,
+				propName,
+				mergedOptions.enumSuffix
+			].filter(Boolean).join(" ")) : basePropName;
 			return (0, _kubb_ast.createProperty)({
 				name: propName,
 				schema: {
-					...convertSchema({
-						schema: resolvedPropSchema,
-						name: name ? pascalCase([
-							name,
-							propName,
-							mergedOptions.enumSuffix
-						].filter(Boolean).join(" ")) : void 0
-					}, options),
+					...isEnumNode && derivedPropName !== basePropName ? {
+						...propNode,
+						name: derivedPropName
+					} : propNode,
 					nullable: propNullable || void 0,
 					optional: !required && !propNullable ? true : void 0,
 					nullish: !required && propNullable ? true : void 0
@@ -1392,15 +1538,15 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 				required
 			});
 		}) : [];
-		const additionalProperties = resolvedSchema.additionalProperties;
+		const additionalProperties = schema.additionalProperties;
 		let additionalPropertiesNode;
 		if (additionalProperties === true) additionalPropertiesNode = true;
 		else if (additionalProperties && Object.keys(additionalProperties).length > 0) additionalPropertiesNode = convertSchema({ schema: additionalProperties }, options);
 		else if (additionalProperties === false) additionalPropertiesNode = void 0;
 		else if (additionalProperties) additionalPropertiesNode = (0, _kubb_ast.createSchema)({ type: resolveTypeOption(mergedOptions.unknownType) });
-		const rawPatternProperties = "patternProperties" in resolvedSchema ? resolvedSchema.patternProperties : void 0;
-		const patternProperties = rawPatternProperties ? Object.fromEntries(Object.entries(rawPatternProperties).map(([pattern, patternSchema]) => [pattern, patternSchema === true || Object.keys(patternSchema).length === 0 ? (0, _kubb_ast.createSchema)({ type: resolveTypeOption(mergedOptions.unknownType) }) : convertSchema({ schema: patternSchema }, options)])) : void 0;
-		return (0, _kubb_ast.createSchema)({
+		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 ? (0, _kubb_ast.createSchema)({ type: resolveTypeOption(mergedOptions.unknownType) }) : convertSchema({ schema: patternSchema }, options)])) : void 0;
+		const objectNode = (0, _kubb_ast.createSchema)({
 			type: "object",
 			primitive: "object",
 			properties,
@@ -1408,6 +1554,20 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			patternProperties,
 			...buildSchemaBase(schema, name, nullable, defaultValue)
 		});
+		if (isDiscriminator(schema) && schema.discriminator.mapping) {
+			const discPropName = schema.discriminator.propertyName;
+			return applyDiscriminatorEnum({
+				node: objectNode,
+				propertyName: discPropName,
+				values: Object.keys(schema.discriminator.mapping),
+				enumName: name ? pascalCase([
+					name,
+					discPropName,
+					mergedOptions.enumSuffix
+				].filter(Boolean).join(" ")) : void 0
+			});
+		}
+		return objectNode;
 	}
 	/**
 	* Converts an OAS 3.1 `prefixItems` tuple into a `TupleSchemaNode`.
@@ -1416,12 +1576,11 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* after the prefix items is mapped to the rest parameter of the tuple.
 	*/
 	function convertTuple({ schema, name, nullable, defaultValue, options }) {
-		const rawSchema = schema;
 		return (0, _kubb_ast.createSchema)({
 			type: "tuple",
 			primitive: "array",
-			items: rawSchema.prefixItems.map((item) => convertSchema({ schema: item }, options)),
-			rest: rawSchema.items ? convertSchema({ schema: rawSchema.items }, options) : void 0,
+			items: (schema.prefixItems ?? []).map((item) => convertSchema({ schema: item }, options)),
+			rest: schema.items ? convertSchema({ schema: schema.items }, options) : void 0,
 			min: schema.minItems,
 			max: schema.maxItems,
 			...buildSchemaBase(schema, name, nullable, defaultValue)
@@ -1434,13 +1593,13 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* `enumSuffix` is forwarded so generators can emit a named enum declaration.
 	*/
 	function convertArray({ schema, name, nullable, defaultValue, options, mergedOptions }) {
-		const rawSchema = schema;
-		const itemName = rawSchema.items?.enum?.length && name ? pascalCase([name, mergedOptions.enumSuffix].join(" ")) : void 0;
+		const rawItems = schema.items;
+		const itemName = rawItems?.enum?.length && name ? pascalCase([name, mergedOptions.enumSuffix].join(" ")) : void 0;
 		return (0, _kubb_ast.createSchema)({
 			type: "array",
 			primitive: "array",
-			items: rawSchema.items ? [convertSchema({
-				schema: rawSchema.items,
+			items: rawItems ? [convertSchema({
+				schema: rawItems,
 				name: itemName
 			}, options)] : [],
 			min: schema.minItems,
@@ -1556,10 +1715,13 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			const arrayNullable = schema.type.includes("null") || nullable || void 0;
 			if (nonNullTypes.length > 1) return (0, _kubb_ast.createSchema)({
 				type: "union",
-				members: nonNullTypes.map((t) => convertSchema({ schema: {
-					...schema,
-					type: t
-				} }, options)),
+				members: nonNullTypes.map((t) => convertSchema({
+					schema: {
+						...schema,
+						type: t
+					},
+					name
+				}, options)),
 				...buildSchemaBase(schema, name, arrayNullable, defaultValue)
 			});
 		}
@@ -1588,12 +1750,17 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* When the parameter has no `schema` or its schema is a `$ref`, falls back to `unknownType`.
 	*/
 	function parseParameter(options, param) {
+		const required = param["required"] ?? false;
 		const schema = param["schema"] && !isReference(param["schema"]) ? convertSchema({ schema: param["schema"] }, options) : (0, _kubb_ast.createSchema)({ type: resolveTypeOption(options.unknownType) });
 		return (0, _kubb_ast.createParameter)({
 			name: param["name"],
 			in: param["in"],
-			schema,
-			required: param["required"] ?? false
+			schema: {
+				...schema,
+				description: param["description"] ?? schema.description,
+				optional: !required || !!schema.optional ? true : void 0
+			},
+			required
 		});
 	}
 	/**
@@ -1601,15 +1768,13 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* request body, and all response codes into their AST node equivalents.
 	*/
 	function parseOperation(options, oas, operation) {
-		const parameters = operation.getParameters().map((param) => {
-			return parseParameter(options, oas.dereferenceWithRef(param));
-		});
+		const parameters = oas.getParameters(operation).map((param) => parseParameter(options, param));
 		const requestBodySchema = oas.getRequestSchema(operation);
 		const requestBody = requestBodySchema ? convertSchema({ schema: requestBodySchema }, options) : void 0;
 		const responses = operation.getResponseStatusCodes().map((statusCode) => {
 			const responseObj = operation.getResponseByStatusCode(statusCode);
 			const responseSchema = oas.getResponseSchema(operation, statusCode);
-			const schema = responseSchema && Object.keys(responseSchema).length > 0 ? convertSchema({ schema: responseSchema }, options) : void 0;
+			const schema = responseSchema && Object.keys(responseSchema).length > 0 ? convertSchema({ schema: responseSchema }, options) : (0, _kubb_ast.createSchema)({ type: resolveTypeOption(options.emptySchemaType) });
 			const description = typeof responseObj === "object" && responseObj !== null && !Array.isArray(responseObj) ? responseObj.description : void 0;
 			const rawContent = typeof responseObj === "object" && responseObj !== null && !Array.isArray(responseObj) ? responseObj.content : void 0;
 			return (0, _kubb_ast.createResponse)({
@@ -1622,7 +1787,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 		return (0, _kubb_ast.createOperation)({
 			operationId: operation.getOperationId(),
 			method: operation.method.toUpperCase(),
-			path: operation.path,
+			path: new URLPath(operation.path).URL,
 			tags: operation.getTags().map((tag) => tag.name),
 			summary: operation.getSummary() || void 0,
 			description: operation.getDescription() || void 0,
@@ -1679,31 +1844,11 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			}
 		} });
 	}
-	/**
-	* Collects all `KubbFile.Import` descriptors needed by a `SchemaNode` tree.
-	*
-	* Walks the tree looking for `ref` nodes, verifies each `$ref` is resolvable in the spec,
-	* applies collision-resolved names from `nameMapping`, and calls `resolve` to obtain the
-	* import path and name. Returns an empty array for refs that cannot be resolved.
-	*/
-	function getImports(node, resolve) {
-		return (0, _kubb_ast.collect)(node, { schema(schemaNode) {
-			if (schemaNode.type !== "ref" || !schemaNode.ref) return;
-			if (!oas.get(schemaNode.ref)) return;
-			const rawName = extractRefName(schemaNode.ref);
-			const result = resolve(nameMapping.get(rawName) ?? rawName);
-			if (!result) return;
-			return {
-				name: [result.name],
-				path: result.path
-			};
-		} });
-	}
 	return {
 		parse,
 		convertSchema,
 		resolveRefs,
-		getImports
+		nameMapping
 	};
 }
 //#endregion
@@ -1727,8 +1872,9 @@ const adapterOasName = "oas";
 * })
 * ```
 */
-const adapterOas = (0, _kubb_core.defineAdapter)((options) => {
+const adapterOas = (0, _kubb_core.createAdapter)((options) => {
 	const { validate = true, oasClass, contentType, serverIndex, serverVariables, discriminator = "strict", collisionDetection = false, dateType = "string", integerType = "number", unknownType = "any", emptySchemaType = unknownType } = options;
+	const nameMapping = /* @__PURE__ */ new Map();
 	return {
 		name: "oas",
 		options: {
@@ -1742,7 +1888,15 @@ const adapterOas = (0, _kubb_core.defineAdapter)((options) => {
 			dateType,
 			integerType,
 			unknownType,
-			emptySchemaType
+			emptySchemaType,
+			nameMapping
+		},
+		getImports(node, resolve) {
+			return getImports({
+				node,
+				nameMapping,
+				resolve
+			});
 		},
 		async parse(source) {
 			const oas = await parseFromConfig(sourceToFakeConfig(source), oasClass);
@@ -1756,11 +1910,14 @@ const adapterOas = (0, _kubb_core.defineAdapter)((options) => {
 			} catch (_err) {}
 			const server = serverIndex !== void 0 ? oas.api.servers?.at(serverIndex) : void 0;
 			const baseURL = server?.url ? resolveServerUrl(server, serverVariables) : void 0;
+			const parser = createOasParser(oas, {
+				contentType,
+				collisionDetection
+			});
+			nameMapping.clear();
+			for (const [key, value] of parser.nameMapping) nameMapping.set(key, value);
 			return (0, _kubb_ast.createRoot)({
-				...createOasParser(oas, {
-					contentType,
-					collisionDetection
-				}).parse({
+				...parser.parse({
 					dateType,
 					integerType,
 					unknownType,
@@ -1768,6 +1925,7 @@ const adapterOas = (0, _kubb_core.defineAdapter)((options) => {
 				}),
 				meta: {
 					title: oas.api.info?.title,
+					description: oas.api.info?.description,
 					version: oas.api.info?.version,
 					baseURL
 				}