@kubb/adapter-oas 5.0.0-beta.91 → 5.0.0-beta.94

package/dist/index.js

@@ -5,18 +5,11 @@ import path from "node:path";
 import { access, readFile } from "node:fs/promises";
 import { compileErrors, validate } from "@readme/openapi-parser";
 import { upgrade } from "@scalar/openapi-upgrader";
-import { parse } from "yaml";
 import { bundle } from "api-ref-bundler";
+import { parse } from "yaml";
 //#region src/constants.ts
 /**
 * Default parser options applied when no explicit options are provided.
-*
-* @example
-* ```ts
-* import { DEFAULT_PARSER_OPTIONS, parseOas } from '@kubb/adapter-oas'
-*
-* const { root } = parseOas(document, { ...DEFAULT_PARSER_OPTIONS, dateType: 'date' })
-* ```
 */
 const DEFAULT_PARSER_OPTIONS = {
 	dateType: "string",
@@ -55,14 +48,6 @@ const SUPPORTED_METHODS = /* @__PURE__ */ new Set([
 *
 * A fragment that contains any of these keys carries structural meaning of its own and must stay as a separate
 * intersection member rather than being merged into the parent.
-*
-* @example
-* ```ts
-* import { structuralKeys } from '@kubb/adapter-oas'
-*
-* const isStructural = Object.keys(fragment).some((key) => structuralKeys.has(key))
-* // true when fragment has e.g. 'properties' or 'oneOf'
-* ```
 */
 const structuralKeys = /* @__PURE__ */ new Set([
 	"properties",
@@ -92,15 +77,6 @@ const specialCasedFormats = /* @__PURE__ */ new Set([
 * Formats that depend on runtime options (`int64`, `date-time`, `date`, `time`) are handled
 * separately in the parser. `ipv4` and `ipv6` map to their own dedicated schema types. `hostname`
 * and `idn-hostname` map to `'url'` as the closest generic string-format type.
-*
-* @example
-* ```ts
-* import { formatMap } from '@kubb/adapter-oas'
-*
-* formatMap['uuid']   // 'uuid'
-* formatMap['binary'] // 'blob'
-* formatMap['float']  // 'number'
-* ```
 */
 const formatMap = {
 	uuid: "uuid",
@@ -121,24 +97,10 @@ const formatMap = {
 };
 /**
 * Vendor extension keys that attach human-readable labels to enum values, checked in priority order.
-*
-* @example
-* ```ts
-* import { enumExtensionKeys } from '@kubb/adapter-oas'
-*
-* const key = enumExtensionKeys.find((k) => k in schema) // 'x-enumNames' | 'x-enum-varnames' | undefined
-* ```
 */
 const enumExtensionKeys = ["x-enumNames", "x-enum-varnames"];
 /**
 * Vendor extension keys that attach human-readable descriptions to enum values, checked in priority order.
-*
-* @example
-* ```ts
-* import { enumDescriptionKeys } from '@kubb/adapter-oas'
-*
-* const key = enumDescriptionKeys.find((k) => k in schema) // 'x-enumDescriptions' | 'x-enum-descriptions' | undefined
-* ```
 */
 const enumDescriptionKeys = ["x-enumDescriptions", "x-enum-descriptions"];
 //#endregion
@@ -382,7 +344,7 @@ async function read(path) {
 	return readFile(path, { encoding: "utf8" });
 }
 //#endregion
-//#region src/bundler.ts
+//#region src/factory.ts
 const urlRegExp = /^https?:\/+/i;
 async function readSource(sourcePath) {
 	if (urlRegExp.test(sourcePath)) {
@@ -425,8 +387,6 @@ async function bundleDocument(pathOrUrl) {
 	await resolver(pathOrUrl);
 	return await bundle(pathOrUrl, resolver);
 }
-//#endregion
-//#region src/factory.ts
 /**
 * Loads and bundles an OpenAPI document, returning the raw `Document`.
 *
@@ -496,19 +456,12 @@ async function validateDocument(document, { throwOnError = false } = {}) {
 	}
 }
 //#endregion
-//#region src/guards.ts
+//#region src/oas.ts
 /**
 * Returns `true` when a schema should be treated as nullable.
 *
 * Recognizes all nullable signals across OAS versions: `nullable: true` (OAS 3.0),
 * `x-nullable: true` (vendor extension), `type: 'null'`, and `type: ['null', ...]` (OAS 3.1).
-*
-* @example
-* ```ts
-* isNullable({ type: 'string', nullable: true }) // true
-* isNullable({ type: ['string', 'null'] })       // true
-* isNullable({ type: 'string' })                 // false
-* ```
 */
 function isNullable(schema) {
 	if ((schema?.nullable ?? schema?.["x-nullable"]) === true) return true;
@@ -519,31 +472,24 @@ function isNullable(schema) {
 }
 /**
 * Returns `true` when `obj` is an OpenAPI `$ref` pointer object.
-*
-* @example
-* ```ts
-* isReference({ $ref: '#/components/schemas/Pet' }) // true
-* isReference({ type: 'string' })                   // false
-* ```
 */
 function isReference(obj) {
 	return !!obj && typeof obj === "object" && "$ref" in obj;
 }
 /**
-* Returns `true` when `obj` is a schema with a structured OAS 3.x `discriminator` object.
-*
-* @example
-* ```ts
-* isDiscriminator({ discriminator: { propertyName: 'type', mapping: {} } }) // true
-* isDiscriminator({ discriminator: 'type' })                                 // false (Swagger 2 string form)
-* ```
+* Returns `true` when `obj` is a schema with a structured OAS 3.x `discriminator` object,
+* excluding the Swagger 2 string form.
 */
 function isDiscriminator(obj) {
 	const record = obj;
 	return !!obj && !!record["discriminator"] && typeof record["discriminator"] !== "string";
 }
-//#endregion
-//#region src/mime.ts
+/**
+* Returns `true` when a schema is a binary payload: an octet-stream string body.
+*/
+function isBinary(schema) {
+	return schema.type === "string" && schema.contentMediaType === "application/octet-stream";
+}
 /**
 * MIME type fragments that mark a media type as JSON-like.
 *
@@ -636,6 +582,23 @@ function dereferenceWithRef(document, schema) {
 	};
 	return schema;
 }
+/**
+* Resolves a `$ref` slot in place: when `container[key]` holds a `$ref`, replaces it with the
+* resolved value and returns that value. Returns `null` when the slot is empty, cannot be resolved,
+* or is still a `$ref` after resolving. A non-`$ref` value is returned untouched, without writing.
+*
+* @example
+* ```ts
+* derefInPlace<ResponseObject>({ document, container: operation.schema.responses, key: '200' })
+* ```
+*/
+function derefInPlace({ document, container, key }) {
+	const value = container[key];
+	if (!isReference(value)) return value ? value : null;
+	const resolved = resolveRef(document, value.$ref);
+	container[key] = resolved;
+	return resolved && !isReference(resolved) ? resolved : null;
+}
 //#endregion
 //#region src/operation.ts
 /**
@@ -667,31 +630,22 @@ function getResponseStatusCodes({ schema }) {
 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;
+	return derefInPlace({
+		document,
+		container: responses,
+		key: statusCode
+	}) ?? false;
 }
 /**
 * 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;
+	return derefInPlace({
+		document,
+		container: operation.schema,
+		key: "requestBody"
+	})?.content;
 }
 /**
 * Returns the request body media type. With `mediaType` set, returns that entry or `false`.
@@ -740,14 +694,12 @@ function getOperations(document) {
 	if (!paths) return operations;
 	for (const path of Object.keys(paths)) {
 		if (path.startsWith("x-")) continue;
-		let pathItem = paths[path];
+		const pathItem = derefInPlace({
+			document,
+			container: paths,
+			key: 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;
@@ -763,37 +715,6 @@ function getOperations(document) {
 	return operations;
 }
 //#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.defineDialect({
-	name: "oas",
-	schema: {
-		isNullable,
-		isReference,
-		isDiscriminator,
-		isBinary: (schema) => schema.type === "string" && schema.contentMediaType === "application/octet-stream",
-		resolveRef
-	}
-});
-//#endregion
 //#region src/resolvers.ts
 /**
 * Reads the server URL from the document's `servers` array at `server.index`,
@@ -901,19 +822,19 @@ function getResponseBody(responseBody, contentType) {
 		if (!(contentType in body.content)) return false;
 		return body.content[contentType];
 	}
-	let availableContentType;
 	const contentTypes = Object.keys(body.content);
-	for (const mt of contentTypes) if (isJsonMimeType(mt)) {
-		availableContentType = mt;
-		break;
-	}
-	if (!availableContentType) availableContentType = contentTypes[0];
-	if (availableContentType) return [
-		availableContentType,
-		body.content[availableContentType],
-		...body.description ? [body.description] : []
-	];
-	return false;
+	const availableContentType = contentTypes.find(isJsonMimeType) ?? contentTypes[0];
+	if (!availableContentType) return false;
+	return body.content[availableContentType];
+}
+function resolveResponseRefs(document, operation) {
+	const responses = operation.schema.responses;
+	if (!responses) return;
+	for (const key in responses) derefInPlace({
+		document,
+		container: responses,
+		key
+	});
 }
 /**
 * Returns the response schema for a given operation and HTTP status code.
@@ -926,14 +847,6 @@ function getResponseBody(responseBody, contentType) {
 * getResponseSchema(document, operation, '4XX')       // {}
 * ```
 */
-function resolveResponseRefs(document, operation) {
-	const responses = operation.schema.responses;
-	if (!responses) return;
-	for (const key in responses) {
-		const schema = responses[key];
-		if (schema && isReference(schema)) responses[key] = resolveRef(document, schema.$ref);
-	}
-}
 function getResponseSchema(document, operation, statusCode, options = {}) {
 	resolveResponseRefs(document, operation);
 	const responseBody = getResponseBody(getResponseByStatusCode({
@@ -942,7 +855,7 @@ function getResponseSchema(document, operation, statusCode, options = {}) {
 		statusCode
 	}), options.contentType);
 	if (responseBody === false) return {};
-	const schema = Array.isArray(responseBody) ? responseBody[1].schema : responseBody.schema;
+	const schema = responseBody.schema;
 	if (!schema) return {};
 	return dereferenceWithRef(document, schema);
 }
@@ -972,6 +885,16 @@ function getRequestSchema(document, operation, options = {}) {
 	return dereferenceWithRef(document, schema);
 }
 /**
+* Returns `true` when `fragment` carries any JSON Schema keyword that makes it
+* structurally significant on its own (see `structuralKeys`).
+*
+* A fragment with a structural keyword can't be safely merged into a parent schema.
+*/
+function hasStructuralKeywords(fragment) {
+	for (const key in fragment) if (structuralKeys.has(key)) return true;
+	return false;
+}
+/**
 * Flattens a keyword-only `allOf` into its parent schema.
 *
 * Only flattens when every member is a plain fragment, with no `$ref` and no structural keywords
@@ -990,16 +913,6 @@ function getRequestSchema(document, operation, options = {}) {
 * // returned unchanged, contains a $ref
 * ```
 */
-/**
-* Returns `true` when `fragment` carries any JSON Schema keyword that makes it
-* structurally significant on its own (see `structuralKeys`).
-*
-* A fragment with a structural keyword can't be safely merged into a parent schema.
-*/
-function hasStructuralKeywords(fragment) {
-	for (const key in fragment) if (structuralKeys.has(key)) return true;
-	return false;
-}
 function flattenSchema(schema) {
 	if (!schema?.allOf || schema.allOf.length === 0) return schema ?? null;
 	const allOfFragments = schema.allOf;
@@ -1251,7 +1164,7 @@ function getResponseBodyContentTypes(document, operation, statusCode) {
 	return body.content ? Object.keys(body.content) : [];
 }
 //#endregion
-//#region src/parser.ts
+//#region src/converters.ts
 /**
 * Normalizes malformed `{ type: 'array', enum: [...] }` schemas by moving enum values into items.
 *
@@ -1275,7 +1188,7 @@ function normalizeArrayEnum(schema) {
 * Builds a `null` scalar node carrying the schema's documentation. Shared by the `const: null`
 * and the drf-spectacular `NullEnum` (`{ enum: [null] }`) branches, which render identically.
 */
-function createNullSchema(schema, name, nullable) {
+function createNullNode(schema, name, nullable) {
 	return ast.factory.createSchema({
 		type: "null",
 		primitive: "null",
@@ -1305,653 +1218,636 @@ function nameEnums(node, options) {
 	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`,
-* which works because function declarations hoist.
+* Converts a `$ref` schema into a `RefSchemaNode`.
 *
-* @internal
+* The resolved schema is stored in `node.schema`. Usage-site sibling fields
+* (description, readOnly, nullable, etc.) are stored directly on the ref node.
+* Use `syncSchemaRef(node)` in printers to get a merged view of both.
+* Circular refs are detected in `resolveRefNode` and leave `schema` as `null`.
 */
-function createSchemaParser(ctx, dialect = oasDialect) {
-	const document = ctx.document;
-	/**
-	* Tracks `$ref` paths that are currently being resolved to prevent infinite
-	* recursion when schemas contain circular references (e.g. `Pet → parent → Pet`).
-	*/
-	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();
-	/**
-	* Memoized record of whether a `$ref` path resolves to a node the document actually defines.
-	* A circular ref still resolves to an existing target, so this stays `true` for cycles and only
-	* goes `false` for a `$ref` that points at a component the spec never declares.
-	*/
-	const refExistence = /* @__PURE__ */ new Map();
-	function refExists(refPath) {
-		if (!refExistence.has(refPath)) {
-			let exists = false;
-			try {
-				exists = !!dialect.schema.resolveRef(document, refPath);
-			} catch {
-				exists = false;
-			}
-			refExistence.set(refPath, exists);
-		}
-		return refExistence.get(refPath) ?? false;
-	}
-	/**
-	* Converts a `$ref` schema into a `RefSchemaNode`.
-	*
-	* The resolved schema is stored in `node.schema`. Usage-site sibling fields
-	* (description, readOnly, nullable, etc.) are stored directly on the ref node.
-	* Use `syncSchemaRef(node)` in printers to get a merged view of both.
-	* Circular refs are detected via `resolvingRefs` and leave `schema` as `undefined`.
-	*/
-	function convertRef({ schema, name, nullable, defaultValue, rawOptions }) {
-		let resolvedSchema = null;
-		const refPath = schema.$ref;
-		if (refPath && !resolvingRefs.has(refPath)) {
-			if (!resolvedRefCache.has(refPath)) {
-				try {
-					const referenced = dialect.schema.resolveRef(document, refPath);
-					if (referenced) {
-						resolvingRefs.add(refPath);
-						resolvedSchema = parseSchema({ schema: referenced }, rawOptions);
-						resolvingRefs.delete(refPath);
-					}
-				} catch {}
-				resolvedRefCache.set(refPath, resolvedSchema);
-			}
-			resolvedSchema = resolvedRefCache.get(refPath) ?? null;
-		}
-		if (refPath && document.components && !refExists(refPath)) return ast.factory.createSchema({
-			...buildSchemaNode(schema, name, nullable, defaultValue),
-			type: "unknown"
-		});
+function convertRef({ schema, name, nullable, defaultValue, rawOptions, document, resolveRefNode, refExists }) {
+	const refPath = schema.$ref;
+	const resolvedSchema = refPath ? resolveRefNode(refPath, rawOptions) : null;
+	if (refPath && document.components && !refExists(refPath)) return ast.factory.createSchema({
+		...buildSchemaNode(schema, name, nullable, defaultValue),
+		type: "unknown"
+	});
+	return ast.factory.createSchema({
+		...buildSchemaNode(schema, name, nullable, defaultValue),
+		type: "ref",
+		name: extractRefName(schema.$ref),
+		ref: schema.$ref,
+		schema: resolvedSchema
+	});
+}
+/**
+* Converts an `allOf` schema into a flattened node or an `IntersectionSchemaNode`.
+*/
+function convertAllOf({ schema, name, nullable, defaultValue, rawOptions, parse, document }) {
+	if (schema.allOf.length === 1 && !schema.properties && !(Array.isArray(schema.required) && schema.required.length) && schema.additionalProperties === void 0) {
+		const [memberSchema] = schema.allOf;
+		const memberNode = parse({
+			schema: memberSchema,
+			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.factory.createSchema({
-			...buildSchemaNode(schema, name, nullable, defaultValue),
-			type: "ref",
-			name: extractRefName(schema.$ref),
-			ref: schema.$ref,
-			schema: resolvedSchema
+			...memberNodeProps,
+			name,
+			title: schema.title ?? memberNode.title,
+			description: schema.description ?? memberNode.description,
+			deprecated: schema.deprecated ?? memberNode.deprecated,
+			nullable: mergedNullable,
+			readOnly: schema.readOnly ?? memberNode.readOnly,
+			writeOnly: schema.writeOnly ?? memberNode.writeOnly,
+			default: mergedDefault,
+			examples: extractExamples(schema) ?? memberNode.examples,
+			pattern: schema.pattern ?? ("pattern" in memberNode ? memberNode.pattern : void 0),
+			format: schema.format ?? memberNode.format
 		});
 	}
-	/**
-	* Converts an `allOf` schema into a flattened node or an `IntersectionSchemaNode`.
-	*/
-	function convertAllOf({ schema, name, nullable, defaultValue, rawOptions }) {
-		if (schema.allOf.length === 1 && !schema.properties && !(Array.isArray(schema.required) && schema.required.length) && schema.additionalProperties === void 0) {
-			const [memberSchema] = schema.allOf;
-			const memberNode = parseSchema({
-				schema: memberSchema,
-				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.factory.createSchema({
-				...memberNodeProps,
-				name,
-				title: schema.title ?? memberNode.title,
-				description: schema.description ?? memberNode.description,
-				deprecated: schema.deprecated ?? memberNode.deprecated,
-				nullable: mergedNullable,
-				readOnly: schema.readOnly ?? memberNode.readOnly,
-				writeOnly: schema.writeOnly ?? memberNode.writeOnly,
-				default: mergedDefault,
-				examples: extractExamples(schema) ?? memberNode.examples,
-				pattern: schema.pattern ?? ("pattern" in memberNode ? memberNode.pattern : void 0),
-				format: schema.format ?? memberNode.format
+	const filteredDiscriminantValues = [];
+	const allOfMembers = schema.allOf.filter((item) => {
+		if (!isReference(item) || !name) return true;
+		const deref = resolveRef(document, item.$ref);
+		if (!deref || !isDiscriminator(deref)) return true;
+		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 inMapping = Object.values(deref.discriminator.mapping ?? {}).some((v) => v === childRef);
+		if (inOneOf || inMapping) {
+			const discriminatorValue = findDiscriminator(deref.discriminator.mapping, childRef);
+			if (discriminatorValue) filteredDiscriminantValues.push({
+				propertyName: deref.discriminator.propertyName,
+				value: discriminatorValue
 			});
+			return false;
 		}
-		const filteredDiscriminantValues = [];
-		const allOfMembers = schema.allOf.filter((item) => {
-			if (!dialect.schema.isReference(item) || !name) return true;
-			const deref = dialect.schema.resolveRef(document, item.$ref);
-			if (!deref || !dialect.schema.isDiscriminator(deref)) return true;
-			const parentUnion = deref.oneOf ?? deref.anyOf;
-			if (!parentUnion) return true;
-			const childRef = `${SCHEMA_REF_PREFIX}${name}`;
-			const inOneOf = parentUnion.some((oneOfItem) => dialect.schema.isReference(oneOfItem) && oneOfItem.$ref === childRef);
-			const inMapping = Object.values(deref.discriminator.mapping ?? {}).some((v) => v === childRef);
-			if (inOneOf || inMapping) {
-				const discriminatorValue = findDiscriminator(deref.discriminator.mapping, childRef);
-				if (discriminatorValue) filteredDiscriminantValues.push({
-					propertyName: deref.discriminator.propertyName,
-					value: discriminatorValue
-				});
-				return false;
-			}
-			return true;
-		}).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 (!dialect.schema.isReference(item)) return [item];
-					const deref = dialect.schema.resolveRef(document, item.$ref);
-					return deref && !dialect.schema.isReference(deref) ? [deref] : [];
-				});
-				for (const key of missingRequired) for (const resolved of resolvedMembers) if (resolved.properties?.[key]) {
-					allOfMembers.push(parseSchema({
-						schema: {
-							properties: { [key]: resolved.properties[key] },
-							required: [key]
-						},
+		return true;
+	}).map((s) => parse({
+		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] : [];
+			});
+			for (const key of missingRequired) for (const resolved of resolvedMembers) {
+				const prop = resolved.properties?.[key];
+				if (prop) {
+					const memberSchema = {
+						properties: { [key]: prop },
+						required: [key]
+					};
+					allOfMembers.push(parse({
+						schema: memberSchema,
 						name
 					}, rawOptions));
 					break;
 				}
 			}
 		}
-		if (schema.properties) {
-			const { allOf: _allOf, ...schemaWithoutAllOf } = schema;
-			allOfMembers.push(parseSchema({ schema: schemaWithoutAllOf }, rawOptions));
-		}
-		for (const { propertyName, value } of filteredDiscriminantValues) allOfMembers.push(createDiscriminantNode({
-			propertyName,
-			value
-		}));
+	}
+	if (schema.properties) {
+		const { allOf: _allOf, ...schemaWithoutAllOf } = schema;
+		allOfMembers.push(parse({ schema: schemaWithoutAllOf }, rawOptions));
+	}
+	for (const { propertyName, value } of filteredDiscriminantValues) allOfMembers.push(createDiscriminantNode({
+		propertyName,
+		value
+	}));
+	return ast.factory.createSchema({
+		type: "intersection",
+		members: [...mergeAdjacentObjectsLazy(allOfMembers.slice(0, syntheticStart)), ...mergeAdjacentObjectsLazy(allOfMembers.slice(syntheticStart))],
+		...buildSchemaNode(schema, name, nullable, defaultValue)
+	});
+}
+/**
+* Converts a `oneOf` / `anyOf` schema into a `UnionSchemaNode`.
+*/
+function convertUnion({ schema, name, nullable, defaultValue, rawOptions, parse, document }) {
+	function pickDiscriminatorPropertyNode(node, propertyName) {
+		const discriminatorProperty = ast.narrowSchema(node, "object")?.properties?.find((property) => property.name === propertyName);
+		if (!discriminatorProperty) return null;
 		return ast.factory.createSchema({
-			type: "intersection",
-			members: [...mergeAdjacentObjectsLazy(allOfMembers.slice(0, syntheticStart)), ...mergeAdjacentObjectsLazy(allOfMembers.slice(syntheticStart))],
-			...buildSchemaNode(schema, name, nullable, defaultValue)
+			type: "object",
+			primitive: "object",
+			properties: [discriminatorProperty]
 		});
 	}
-	/**
-	* Converts a `oneOf` / `anyOf` schema into a `UnionSchemaNode`.
-	*/
-	function convertUnion({ schema, name, nullable, defaultValue, rawOptions }) {
-		function pickDiscriminatorPropertyNode(node, propertyName) {
-			const discriminatorProperty = ast.narrowSchema(node, "object")?.properties?.find((property) => property.name === propertyName);
-			if (!discriminatorProperty) return null;
-			return ast.factory.createSchema({
-				type: "object",
-				primitive: "object",
-				properties: [discriminatorProperty]
+	function resolveRefSilent($ref) {
+		if (!$ref.startsWith("#")) return null;
+		return decodeURIComponent($ref.substring(1)).split("/").filter(Boolean).reduce((obj, key) => obj?.[key], document) ?? null;
+	}
+	function implicitDiscriminantValue(member) {
+		if (!discriminator || discriminator.mapping || !isReference(member)) return null;
+		const value = extractRefName(member.$ref);
+		if (!value) return null;
+		const variant = resolveRefSilent(member.$ref);
+		if (!variant) return null;
+		const propertyName = discriminator.propertyName;
+		const seen = /* @__PURE__ */ new Set([member.$ref]);
+		function constrains(v) {
+			const prop = v.properties?.[propertyName];
+			const resolved = prop && isReference(prop) ? resolveRefSilent(prop.$ref) : prop;
+			if (resolved && (Array.isArray(resolved.enum) || resolved.const !== void 0)) return true;
+			const composition = v.allOf ?? v.oneOf ?? v.anyOf;
+			if (!composition) return false;
+			return composition.some((m) => {
+				if (!isReference(m)) return constrains(m);
+				if (seen.has(m.$ref)) return false;
+				seen.add(m.$ref);
+				const r = resolveRefSilent(m.$ref);
+				return r ? constrains(r) : false;
 			});
 		}
-		function resolveRefSilent($ref) {
-			if (!$ref.startsWith("#")) return null;
-			return decodeURIComponent($ref.substring(1)).split("/").filter(Boolean).reduce((obj, key) => obj?.[key], document) ?? null;
-		}
-		function implicitDiscriminantValue(member) {
-			if (!discriminator || discriminator.mapping || !dialect.schema.isReference(member)) return null;
-			const value = extractRefName(member.$ref);
-			if (!value) return null;
-			const variant = resolveRefSilent(member.$ref);
-			if (!variant) return null;
-			const propertyName = discriminator.propertyName;
-			const seen = /* @__PURE__ */ new Set([member.$ref]);
-			function constrains(v) {
-				const prop = v.properties?.[propertyName];
-				const resolved = prop && dialect.schema.isReference(prop) ? resolveRefSilent(prop.$ref) : prop;
-				if (resolved && (Array.isArray(resolved.enum) || resolved.const !== void 0)) return true;
-				const composition = v.allOf ?? v.oneOf ?? v.anyOf;
-				if (!composition) return false;
-				return composition.some((m) => {
-					if (!dialect.schema.isReference(m)) return constrains(m);
-					if (seen.has(m.$ref)) return false;
-					seen.add(m.$ref);
-					const r = resolveRefSilent(m.$ref);
-					return r ? constrains(r) : false;
-				});
-			}
-			return constrains(variant) ? null : value;
-		}
-		const unionMembers = [...schema.oneOf ?? [], ...schema.anyOf ?? []];
-		const strategy = schema.oneOf ? "one" : "any";
-		const unionBase = {
-			...buildSchemaNode(schema, name, nullable, defaultValue),
-			discriminatorPropertyName: dialect.schema.isDiscriminator(schema) ? schema.discriminator.propertyName : void 0,
-			strategy
-		};
-		const discriminator = dialect.schema.isDiscriminator(schema) ? schema.discriminator : void 0;
-		const { oneOf: _o, anyOf: _a, discriminator: _d, ...memberBaseSchema } = schema;
-		const sharedPropertiesNode = schema.properties ? parseSchema({
-			schema: memberBaseSchema,
-			name
-		}, rawOptions) : void 0;
-		if (sharedPropertiesNode || discriminator) {
-			const members = unionMembers.map((s) => {
-				const ref = dialect.schema.isReference(s) ? s.$ref : void 0;
-				const discriminatorValue = findDiscriminator(discriminator?.mapping, ref) ?? implicitDiscriminantValue(s);
-				const memberNode = parseSchema({
-					schema: s,
-					name
-				}, rawOptions);
-				if (!discriminatorValue || !discriminator) return memberNode;
-				const narrowedDiscriminatorNode = sharedPropertiesNode ? pickDiscriminatorPropertyNode(ast.applyMacros(sharedPropertiesNode, [macroDiscriminatorEnum({
-					propertyName: discriminator.propertyName,
-					values: [discriminatorValue]
-				})], { depth: "shallow" }), discriminator.propertyName) : void 0;
-				return ast.factory.createSchema({
-					type: "intersection",
-					members: [memberNode, narrowedDiscriminatorNode ?? createDiscriminantNode({
-						propertyName: discriminator.propertyName,
-						value: discriminatorValue
-					})]
-				});
-			});
-			const unionNode = ast.factory.createSchema({
-				type: "union",
-				...unionBase,
-				members
-			});
-			if (!sharedPropertiesNode) return unionNode;
+		return constrains(variant) ? null : value;
+	}
+	const unionMembers = [...schema.oneOf ?? [], ...schema.anyOf ?? []];
+	const strategy = schema.oneOf ? "one" : "any";
+	const unionBase = {
+		...buildSchemaNode(schema, name, nullable, defaultValue),
+		discriminatorPropertyName: isDiscriminator(schema) ? schema.discriminator.propertyName : void 0,
+		strategy
+	};
+	const discriminator = isDiscriminator(schema) ? schema.discriminator : void 0;
+	const { oneOf: _o, anyOf: _a, discriminator: _d, ...memberBaseSchema } = schema;
+	const sharedPropertiesNode = schema.properties ? parse({
+		schema: memberBaseSchema,
+		name
+	}, rawOptions) : void 0;
+	if (sharedPropertiesNode || discriminator) {
+		const members = unionMembers.map((s) => {
+			const ref = isReference(s) ? s.$ref : void 0;
+			const discriminatorValue = findDiscriminator(discriminator?.mapping, ref) ?? implicitDiscriminantValue(s);
+			const memberNode = parse({
+				schema: s,
+				name
+			}, rawOptions);
+			if (!discriminatorValue || !discriminator) return memberNode;
+			const narrowedDiscriminatorNode = sharedPropertiesNode ? pickDiscriminatorPropertyNode(ast.applyMacros(sharedPropertiesNode, [macroDiscriminatorEnum({
+				propertyName: discriminator.propertyName,
+				values: [discriminatorValue]
+			})], { depth: "shallow" }), discriminator.propertyName) : void 0;
 			return ast.factory.createSchema({
 				type: "intersection",
-				...buildSchemaNode(schema, name, nullable, defaultValue),
-				members: [unionNode, sharedPropertiesNode]
+				members: [memberNode, narrowedDiscriminatorNode ?? createDiscriminantNode({
+					propertyName: discriminator.propertyName,
+					value: discriminatorValue
+				})]
 			});
-		}
+		});
 		const unionNode = ast.factory.createSchema({
 			type: "union",
 			...unionBase,
-			members: unionMembers.map((s) => parseSchema({
-				schema: s,
-				name
-			}, rawOptions))
+			members
 		});
-		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 createNullSchema(schema, name);
-		const constPrimitive = getPrimitiveType(typeof constValue === "number" ? "number" : typeof constValue === "boolean" ? "boolean" : "string");
+		if (!sharedPropertiesNode) return unionNode;
 		return ast.factory.createSchema({
-			type: "enum",
-			primitive: constPrimitive,
-			enumValues: [constValue],
-			...buildSchemaNode(schema, name, nullable, defaultValue)
+			type: "intersection",
+			...buildSchemaNode(schema, name, nullable, defaultValue),
+			members: [unionNode, sharedPropertiesNode]
 		});
 	}
-	/**
-	* Converts a format-annotated schema into a special-type `SchemaNode`.
-	* Returns `null` when the format should fall through to string handling (`dateType: false`).
-	*/
-	function convertFormat({ schema, name, nullable, defaultValue, options }) {
-		const base = buildSchemaNode(schema, name, nullable, defaultValue);
-		if (schema.format === "int64") return ast.factory.createSchema({
-			type: options.integerType === "bigint" ? "bigint" : "integer",
-			primitive: "integer",
-			...base,
-			min: schema.minimum,
-			max: schema.maximum,
-			exclusiveMinimum: typeof schema.exclusiveMinimum === "number" ? schema.exclusiveMinimum : void 0,
-			exclusiveMaximum: typeof schema.exclusiveMaximum === "number" ? schema.exclusiveMaximum : void 0
-		});
-		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.factory.createSchema({
-				...base,
-				primitive: "string",
-				type: "datetime",
-				offset: dateType.offset,
-				local: dateType.local
-			});
-			return ast.factory.createSchema({
-				...base,
-				primitive: "string",
-				type: dateType.type,
-				representation: dateType.representation
-			});
-		}
-		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.factory.createSchema({
-			...base,
-			primitive: specialPrimitive,
-			type: specialType
-		});
-		if (specialType === "url") return ast.factory.createSchema({
-			...base,
-			primitive: "string",
-			type: "url",
-			min: schema.minLength,
-			max: schema.maxLength
-		});
-		if (specialType === "ipv4") return ast.factory.createSchema({
+	const unionNode = ast.factory.createSchema({
+		type: "union",
+		...unionBase,
+		members: unionMembers.map((s) => parse({
+			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 createNullNode(schema, name);
+	const constPrimitive = getPrimitiveType(typeof constValue === "number" ? "number" : typeof constValue === "boolean" ? "boolean" : "string");
+	return ast.factory.createSchema({
+		type: "enum",
+		primitive: constPrimitive,
+		enumValues: [constValue],
+		...buildSchemaNode(schema, name, nullable, defaultValue)
+	});
+}
+/**
+* Converts a format-annotated schema into a special-type `SchemaNode`.
+* Returns `null` when the format should fall through to string handling (`dateType: false`).
+*/
+function convertFormat({ schema, name, nullable, defaultValue, options }) {
+	const base = buildSchemaNode(schema, name, nullable, defaultValue);
+	if (schema.format === "int64") return ast.factory.createSchema({
+		type: options.integerType === "bigint" ? "bigint" : "integer",
+		primitive: "integer",
+		...base,
+		min: schema.minimum,
+		max: schema.maximum,
+		exclusiveMinimum: typeof schema.exclusiveMinimum === "number" ? schema.exclusiveMinimum : void 0,
+		exclusiveMaximum: typeof schema.exclusiveMaximum === "number" ? schema.exclusiveMaximum : void 0
+	});
+	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.factory.createSchema({
 			...base,
 			primitive: "string",
-			type: "ipv4"
+			type: "datetime",
+			offset: dateType.offset,
+			local: dateType.local
 		});
-		if (specialType === "ipv6") return ast.factory.createSchema({
+		return ast.factory.createSchema({
 			...base,
 			primitive: "string",
-			type: "ipv6"
+			type: dateType.type,
+			representation: dateType.representation
 		});
-		if (specialType === "uuid" || specialType === "email") return ast.factory.createSchema({
-			...base,
-			primitive: "string",
-			type: specialType,
+	}
+	const specialType = getSchemaType(schema.format);
+	if (!specialType) return null;
+	const specialPrimitive = specialType === "number" || specialType === "integer" || specialType === "bigint" ? specialType : "string";
+	const hasLength = specialType === "url" || specialType === "uuid" || specialType === "email";
+	return ast.factory.createSchema({
+		...base,
+		primitive: specialPrimitive,
+		type: specialType,
+		...hasLength ? {
 			min: schema.minLength,
 			max: schema.maxLength
-		});
-		return ast.factory.createSchema({
-			...base,
-			primitive: specialPrimitive,
-			type: specialType
-		});
-	}
-	/**
-	* Converts an `enum` schema into an `EnumSchemaNode`.
-	*/
-	function convertEnum({ schema, name, nullable, type, rawOptions }) {
-		if (type === "array") return parseSchema({
-			schema: normalizeArrayEnum(schema),
-			name
-		}, rawOptions);
-		const nullInEnum = schema.enum.includes(null);
-		const filteredValues = nullInEnum ? schema.enum.filter((v) => v !== null) : schema.enum;
-		if (nullInEnum && filteredValues.length === 0) return createNullSchema(schema, name);
-		const enumNullable = nullable || nullInEnum || void 0;
-		const enumDefault = schema.default === null && enumNullable ? void 0 : schema.default;
-		const enumPrimitive = getPrimitiveType(type);
-		const enumBase = {
-			type: "enum",
-			primitive: enumPrimitive,
-			name,
-			title: schema.title,
-			description: schema.description,
-			deprecated: schema.deprecated,
-			nullable: enumNullable,
-			readOnly: schema.readOnly,
-			writeOnly: schema.writeOnly,
-			default: enumDefault,
-			examples: extractExamples(schema),
-			format: schema.format
-		};
-		const extensionKey = enumExtensionKeys.find((key) => key in schema);
-		const descriptionKey = enumDescriptionKeys.find((key) => key in schema);
-		if (extensionKey || descriptionKey || enumPrimitive === "number" || enumPrimitive === "integer" || enumPrimitive === "boolean") {
-			const enumPrimitiveType = enumPrimitive === "number" || enumPrimitive === "integer" ? "number" : enumPrimitive === "boolean" ? "boolean" : "string";
-			const rawEnumNames = extensionKey ? schema[extensionKey] : void 0;
-			const rawEnumDescriptions = descriptionKey ? schema[descriptionKey] : void 0;
-			const uniqueValues = [...new Set(filteredValues)];
-			const seenNames = /* @__PURE__ */ new Set();
-			return ast.factory.createSchema({
-				...enumBase,
-				primitive: enumPrimitiveType,
-				namedEnumValues: uniqueValues.map((value, index) => ({
-					name: String(rawEnumNames?.[index] ?? value),
-					value,
-					primitive: enumPrimitiveType,
-					description: rawEnumDescriptions?.[index]
-				})).filter((entry) => {
-					if (seenNames.has(entry.name)) return false;
-					seenNames.add(entry.name);
-					return true;
-				})
-			});
-		}
+		} : {}
+	});
+}
+/**
+* Converts an `enum` schema into an `EnumSchemaNode`.
+*/
+function convertEnum({ schema, name, nullable, type, rawOptions, parse }) {
+	if (type === "array") return parse({
+		schema: normalizeArrayEnum(schema),
+		name
+	}, rawOptions);
+	const nullInEnum = schema.enum.includes(null);
+	const filteredValues = nullInEnum ? schema.enum.filter((v) => v !== null) : schema.enum;
+	if (nullInEnum && filteredValues.length === 0) return createNullNode(schema, name);
+	const enumNullable = nullable || nullInEnum || void 0;
+	const enumDefault = schema.default === null && enumNullable ? void 0 : schema.default;
+	const enumPrimitive = getPrimitiveType(type);
+	const enumBase = {
+		type: "enum",
+		primitive: enumPrimitive,
+		...buildSchemaNode(schema, name, enumNullable, enumDefault)
+	};
+	const extensionKey = enumExtensionKeys.find((key) => key in schema);
+	const descriptionKey = enumDescriptionKeys.find((key) => key in schema);
+	if (extensionKey || descriptionKey || enumPrimitive === "number" || enumPrimitive === "integer" || enumPrimitive === "boolean") {
+		const enumPrimitiveType = enumPrimitive === "number" || enumPrimitive === "integer" ? "number" : enumPrimitive === "boolean" ? "boolean" : "string";
+		const rawEnumNames = extensionKey ? schema[extensionKey] : void 0;
+		const rawEnumDescriptions = descriptionKey ? schema[descriptionKey] : void 0;
+		const uniqueValues = [...new Set(filteredValues)];
+		const seenNames = /* @__PURE__ */ new Set();
 		return ast.factory.createSchema({
 			...enumBase,
-			enumValues: [...new Set(filteredValues)]
-		});
-	}
-	/**
-	* Converts an object-like schema into an `ObjectSchemaNode`.
-	*/
-	function convertObject({ schema, name, nullable, defaultValue, rawOptions, options }) {
-		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 = dialect.schema.isNullable(resolvedPropSchema);
-			const schemaNode = nameEnums(parseSchema({
-				schema: resolvedPropSchema,
-				name: childName(name, propName)
-			}, rawOptions), {
-				parentName: name,
-				propName,
-				enumSuffix: options.enumSuffix
-			});
-			return ast.factory.createProperty({
-				name: propName,
-				schema: {
-					...schemaNode,
-					nullable: schemaNode.type === "null" ? void 0 : propNullable || void 0
-				},
-				required
-			});
-		}) : [];
-		const additionalProperties = schema.additionalProperties;
-		const additionalPropertiesNode = (() => {
-			if (additionalProperties === true) return true;
-			if (additionalProperties === false) return false;
-			if (additionalProperties && Object.keys(additionalProperties).length > 0) return parseSchema({ schema: additionalProperties }, rawOptions);
-			if (additionalProperties) return ast.factory.createSchema({ type: options.unknownType });
-		})();
-		const rawPatternProperties = "patternProperties" in schema ? schema.patternProperties : void 0;
-		const patternProperties = rawPatternProperties ? Object.fromEntries(Object.entries(rawPatternProperties).map(([pattern, patternSchema]) => [pattern, patternSchema === true || typeof patternSchema === "object" && Object.keys(patternSchema).length === 0 ? ast.factory.createSchema({ type: options.unknownType }) : parseSchema({ schema: patternSchema }, rawOptions)])) : void 0;
-		const objectNode = ast.factory.createSchema({
-			type: "object",
-			primitive: "object",
-			properties,
-			additionalProperties: additionalPropertiesNode,
-			patternProperties,
-			minProperties: schema.minProperties,
-			maxProperties: schema.maxProperties,
-			...buildSchemaNode(schema, name, nullable, defaultValue)
-		});
-		if (dialect.schema.isDiscriminator(schema) && schema.discriminator.mapping) {
-			const discPropName = schema.discriminator.propertyName;
-			const values = Object.keys(schema.discriminator.mapping);
-			const enumName = name ? enumPropName(name, discPropName, options.enumSuffix) : void 0;
-			return ast.applyMacros(objectNode, [macroDiscriminatorEnum({
-				propertyName: discPropName,
-				values,
-				enumName
-			})], { depth: "shallow" });
-		}
-		return objectNode;
-	}
-	/**
-	* Converts an OAS 3.1 `prefixItems` tuple into a `TupleSchemaNode`.
-	*/
-	function convertTuple({ schema, name, nullable, defaultValue, rawOptions }) {
-		const tupleItems = (schema.prefixItems ?? []).map((item) => parseSchema({ schema: item }, rawOptions));
-		const rest = schema.items === false ? void 0 : !schema.items || schema.items === true ? ast.factory.createSchema({ type: "any" }) : parseSchema({ schema: schema.items }, rawOptions);
-		return ast.factory.createSchema({
-			type: "tuple",
-			primitive: "array",
-			items: tupleItems,
-			rest,
-			min: schema.minItems,
-			max: schema.maxItems,
-			...buildSchemaNode(schema, name, nullable, defaultValue)
+			primitive: enumPrimitiveType,
+			namedEnumValues: uniqueValues.map((value, index) => ({
+				name: String(rawEnumNames?.[index] ?? value),
+				value,
+				primitive: enumPrimitiveType,
+				description: rawEnumDescriptions?.[index]
+			})).filter((entry) => {
+				if (seenNames.has(entry.name)) return false;
+				seenNames.add(entry.name);
+				return true;
+			})
 		});
 	}
-	/**
-	* Converts a `type: 'array'` schema into an `ArraySchemaNode`.
-	*/
-	function convertArray({ schema, name, nullable, defaultValue, rawOptions, options }) {
-		const rawItems = schema.items;
-		const itemName = rawItems?.enum?.length && name ? enumPropName(null, name, options.enumSuffix) : name;
-		const items = rawItems ? [parseSchema({
-			schema: rawItems,
-			name: itemName
-		}, rawOptions)] : [];
-		return ast.factory.createSchema({
-			type: "array",
-			primitive: "array",
-			items,
-			min: schema.minItems,
-			max: schema.maxItems,
-			unique: schema.uniqueItems ?? void 0,
-			...buildSchemaNode(schema, name, nullable, defaultValue)
+	return ast.factory.createSchema({
+		...enumBase,
+		enumValues: [...new Set(filteredValues)]
+	});
+}
+/**
+* Converts an object-like schema into an `ObjectSchemaNode`.
+*/
+function convertObject({ schema, name, nullable, defaultValue, rawOptions, options, parse }) {
+	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 schemaNode = nameEnums(parse({
+			schema: resolvedPropSchema,
+			name: childName(name, propName)
+		}, rawOptions), {
+			parentName: name,
+			propName,
+			enumSuffix: options.enumSuffix
 		});
-	}
-	/**
-	* Converts a `type: 'string'` schema into a `StringSchemaNode`.
-	*/
-	function convertString({ schema, name, nullable, defaultValue }) {
-		return ast.factory.createSchema({
-			type: "string",
-			primitive: "string",
-			min: schema.minLength,
-			max: schema.maxLength,
-			pattern: schema.pattern,
-			...buildSchemaNode(schema, name, nullable, defaultValue)
+		return ast.factory.createProperty({
+			name: propName,
+			schema: {
+				...schemaNode,
+				nullable: schemaNode.type === "null" ? void 0 : propNullable || void 0
+			},
+			required
 		});
+	}) : [];
+	const additionalProperties = schema.additionalProperties;
+	const additionalPropertiesNode = (() => {
+		if (additionalProperties === true) return true;
+		if (additionalProperties === false) return false;
+		if (additionalProperties && Object.keys(additionalProperties).length > 0) return parse({ schema: additionalProperties }, rawOptions);
+		if (additionalProperties) return ast.factory.createSchema({ type: options.unknownType });
+	})();
+	const rawPatternProperties = "patternProperties" in schema ? schema.patternProperties : void 0;
+	const patternProperties = rawPatternProperties ? Object.fromEntries(Object.entries(rawPatternProperties).map(([pattern, patternSchema]) => [pattern, patternSchema === true || typeof patternSchema === "object" && Object.keys(patternSchema).length === 0 ? ast.factory.createSchema({ type: options.unknownType }) : parse({ schema: patternSchema }, rawOptions)])) : void 0;
+	const objectNode = ast.factory.createSchema({
+		type: "object",
+		primitive: "object",
+		properties,
+		additionalProperties: additionalPropertiesNode,
+		patternProperties,
+		minProperties: schema.minProperties,
+		maxProperties: schema.maxProperties,
+		...buildSchemaNode(schema, name, nullable, defaultValue)
+	});
+	if (isDiscriminator(schema) && schema.discriminator.mapping) {
+		const discPropName = schema.discriminator.propertyName;
+		const values = Object.keys(schema.discriminator.mapping);
+		const enumName = name ? enumPropName(name, discPropName, options.enumSuffix) : void 0;
+		return ast.applyMacros(objectNode, [macroDiscriminatorEnum({
+			propertyName: discPropName,
+			values,
+			enumName
+		})], { depth: "shallow" });
 	}
-	/**
-	* Converts a `type: 'number'` or `type: 'integer'` schema.
-	*/
-	function convertNumeric({ schema, name, nullable, defaultValue }, type) {
-		return ast.factory.createSchema({
-			type,
-			primitive: type,
-			min: schema.minimum,
-			max: schema.maximum,
-			exclusiveMinimum: typeof schema.exclusiveMinimum === "number" ? schema.exclusiveMinimum : void 0,
-			exclusiveMaximum: typeof schema.exclusiveMaximum === "number" ? schema.exclusiveMaximum : void 0,
-			multipleOf: schema.multipleOf,
-			...buildSchemaNode(schema, name, nullable, defaultValue)
-		});
+	return objectNode;
+}
+/**
+* Converts an OAS 3.1 `prefixItems` tuple into a `TupleSchemaNode`.
+*/
+function convertTuple({ schema, name, nullable, defaultValue, rawOptions, parse }) {
+	const tupleItems = (schema.prefixItems ?? []).map((item) => parse({ schema: item }, rawOptions));
+	const rest = schema.items === false ? void 0 : !schema.items || schema.items === true ? ast.factory.createSchema({ type: "any" }) : parse({ schema: schema.items }, rawOptions);
+	return ast.factory.createSchema({
+		type: "tuple",
+		primitive: "array",
+		items: tupleItems,
+		rest,
+		min: schema.minItems,
+		max: schema.maxItems,
+		...buildSchemaNode(schema, name, nullable, defaultValue)
+	});
+}
+/**
+* Converts a `type: 'array'` schema into an `ArraySchemaNode`.
+*/
+function convertArray({ schema, name, nullable, defaultValue, rawOptions, options, parse }) {
+	const rawItems = schema.items;
+	const itemName = rawItems?.enum?.length && name ? enumPropName(null, name, options.enumSuffix) : name;
+	const items = rawItems ? [parse({
+		schema: rawItems,
+		name: itemName
+	}, rawOptions)] : [];
+	return ast.factory.createSchema({
+		type: "array",
+		primitive: "array",
+		items,
+		min: schema.minItems,
+		max: schema.maxItems,
+		unique: schema.uniqueItems ?? void 0,
+		...buildSchemaNode(schema, name, nullable, defaultValue)
+	});
+}
+/**
+* Converts a `type: 'string'` schema into a `StringSchemaNode`.
+*/
+function convertString({ schema, name, nullable, defaultValue }) {
+	return ast.factory.createSchema({
+		type: "string",
+		primitive: "string",
+		min: schema.minLength,
+		max: schema.maxLength,
+		pattern: schema.pattern,
+		...buildSchemaNode(schema, name, nullable, defaultValue)
+	});
+}
+/**
+* Converts a `type: 'number'` or `type: 'integer'` schema.
+*/
+function convertNumeric({ schema, name, nullable, defaultValue }, type) {
+	return ast.factory.createSchema({
+		type,
+		primitive: type,
+		min: schema.minimum,
+		max: schema.maximum,
+		exclusiveMinimum: typeof schema.exclusiveMinimum === "number" ? schema.exclusiveMinimum : void 0,
+		exclusiveMaximum: typeof schema.exclusiveMaximum === "number" ? schema.exclusiveMaximum : void 0,
+		multipleOf: schema.multipleOf,
+		...buildSchemaNode(schema, name, nullable, defaultValue)
+	});
+}
+/**
+* Converts a `type: 'boolean'` schema.
+*/
+function convertBoolean({ schema, name, nullable, defaultValue }) {
+	return ast.factory.createSchema({
+		type: "boolean",
+		primitive: "boolean",
+		...buildSchemaNode(schema, name, nullable, defaultValue)
+	});
+}
+/**
+* Converts a binary string schema (`type: 'string'`, `contentMediaType: 'application/octet-stream'`)
+* into a `blob` node.
+*/
+function convertBinary({ 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 `parse`
+* falls through and handles it as that single type with nullability already folded in.
+*/
+function convertMultiType({ schema, name, nullable, defaultValue, rawOptions, parse }) {
+	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) => {
+			return parse({
+				schema: {
+					...schema,
+					type: t
+				},
+				name
+			}, rawOptions);
+		}),
+		...buildSchemaNode(schema, name, arrayNullable, defaultValue)
+	});
+}
+/**
+* Ordered schema rule table. Order is significant: composition keywords (`$ref`, `allOf`,
+* `oneOf`/`anyOf`) take precedence over `const`/`format`, which take precedence over the plain
+* `type`. The first matching rule that produces a node wins. See {@link SchemaRule} for the
+* match/convert/fall-through contract.
+*/
+const schemaRules = [
+	{
+		match: ({ schema }) => isReference(schema),
+		convert: convertRef
+	},
+	{
+		match: ({ schema }) => !!schema.allOf?.length,
+		convert: convertAllOf
+	},
+	{
+		match: ({ schema }) => !!(schema.oneOf?.length || schema.anyOf?.length),
+		convert: convertUnion
+	},
+	{
+		match: ({ schema }) => "const" in schema && schema.const !== void 0,
+		convert: convertConst
+	},
+	{
+		match: ({ schema }) => !!schema.format,
+		convert: convertFormat
+	},
+	{
+		match: ({ schema }) => isBinary(schema),
+		convert: convertBinary
+	},
+	{
+		match: ({ schema }) => Array.isArray(schema.type) && schema.type.length > 1,
+		convert: convertMultiType
+	},
+	{
+		match: ({ schema, type }) => !type && (schema.minLength !== void 0 || schema.maxLength !== void 0 || schema.pattern !== void 0),
+		convert: convertString
+	},
+	{
+		match: ({ schema, type }) => !type && (schema.minimum !== void 0 || schema.maximum !== void 0),
+		convert: (ctx) => convertNumeric(ctx, "number")
+	},
+	{
+		match: ({ schema }) => !!schema.enum?.length,
+		convert: convertEnum
+	},
+	{
+		match: ({ schema, type }) => type === "object" || !!schema.properties || !!schema.additionalProperties || "patternProperties" in schema,
+		convert: convertObject
+	},
+	{
+		match: ({ schema }) => "prefixItems" in schema,
+		convert: convertTuple
+	},
+	{
+		match: ({ schema, type }) => type === "array" || "items" in schema,
+		convert: convertArray
+	},
+	{
+		match: ({ type }) => type === "string",
+		convert: convertString
+	},
+	{
+		match: ({ type }) => type === "number",
+		convert: (ctx) => convertNumeric(ctx, "number")
+	},
+	{
+		match: ({ type }) => type === "integer",
+		convert: (ctx) => convertNumeric(ctx, "integer")
+	},
+	{
+		match: ({ type }) => type === "boolean",
+		convert: convertBoolean
+	},
+	{
+		match: ({ type }) => type === "null",
+		convert: ({ schema, name, nullable }) => createNullNode(schema, name, nullable)
 	}
+];
+//#endregion
+//#region src/parser.ts
+/**
+* Creates the schema and operation converters bound to one OpenAPI document.
+*
+* Owns the per-instance `$ref` state (cycle detection, resolved-node cache, existence cache) and
+* the `parseSchema` recursion seam, then dispatches each schema through the ordered `schemaRules`
+* table from `converters.ts`. Every converter is a standalone function that recurses through the
+* `parse` function passed to it, so this file only wires state to the converters.
+*
+* @internal
+*/
+function createSchemaParser(ctx) {
+	const document = ctx.document;
 	/**
-	* Converts a `type: 'boolean'` schema.
+	* Tracks `$ref` paths that are currently being resolved to prevent infinite
+	* recursion when schemas contain circular references (e.g. `Pet → parent → Pet`).
 	*/
-	function convertBoolean({ schema, name, nullable, defaultValue }) {
-		return ast.factory.createSchema({
-			type: "boolean",
-			primitive: "boolean",
-			...buildSchemaNode(schema, name, nullable, defaultValue)
-		});
-	}
+	const resolvingRefs = /* @__PURE__ */ new Set();
 	/**
-	* Converts a binary string schema (`type: 'string'`, `contentMediaType: 'application/octet-stream'`)
-	* into a `blob` node.
+	* 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.
 	*/
-	function convertBlob({ schema, name, nullable, defaultValue }) {
-		return ast.factory.createSchema({
-			type: "blob",
-			primitive: "string",
-			...buildSchemaNode(schema, name, nullable, defaultValue)
-		});
-	}
+	const resolvedRefCache = /* @__PURE__ */ new Map();
 	/**
-	* 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.
+	* Memoized record of whether a `$ref` path resolves to a node the document actually defines.
+	* A circular ref still resolves to an existing target, so this stays `true` for cycles and only
+	* goes `false` for a `$ref` that points at a component the spec never declares.
 	*/
-	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)
-		});
+	const refExistence = /* @__PURE__ */ new Map();
+	function refExists(refPath) {
+		if (!refExistence.has(refPath)) {
+			let exists = false;
+			try {
+				exists = !!resolveRef(document, refPath);
+			} catch {
+				exists = false;
+			}
+			refExistence.set(refPath, exists);
+		}
+		return refExistence.get(refPath) ?? false;
 	}
 	/**
-	* 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.
+	* Resolves a `$ref` to its parsed node, guarding against cycles and memoizing per instance.
+	* Returns `null` when the ref is currently being resolved (a cycle) or cannot be resolved
+	* (e.g. a minimal document in a unit test).
 	*/
-	const schemaRules = [
-		{
-			match: ({ schema }) => dialect.schema.isReference(schema),
-			convert: convertRef
-		},
-		{
-			match: ({ schema }) => !!schema.allOf?.length,
-			convert: convertAllOf
-		},
-		{
-			match: ({ schema }) => !!(schema.oneOf?.length || schema.anyOf?.length),
-			convert: convertUnion
-		},
-		{
-			match: ({ schema }) => "const" in schema && schema.const !== void 0,
-			convert: convertConst
-		},
-		{
-			match: ({ schema }) => !!schema.format,
-			convert: convertFormat
-		},
-		{
-			match: ({ schema }) => dialect.schema.isBinary(schema),
-			convert: convertBlob
-		},
-		{
-			match: ({ schema }) => Array.isArray(schema.type) && schema.type.length > 1,
-			convert: convertMultiType
-		},
-		{
-			match: ({ schema, type }) => !type && (schema.minLength !== void 0 || schema.maxLength !== void 0 || schema.pattern !== void 0),
-			convert: convertString
-		},
-		{
-			match: ({ schema, type }) => !type && (schema.minimum !== void 0 || schema.maximum !== void 0),
-			convert: (ctx) => convertNumeric(ctx, "number")
-		},
-		{
-			match: ({ schema }) => !!schema.enum?.length,
-			convert: convertEnum
-		},
-		{
-			match: ({ schema, type }) => type === "object" || !!schema.properties || !!schema.additionalProperties || "patternProperties" in schema,
-			convert: convertObject
-		},
-		{
-			match: ({ schema }) => "prefixItems" in schema,
-			convert: convertTuple
-		},
-		{
-			match: ({ schema, type }) => type === "array" || "items" in schema,
-			convert: convertArray
-		},
-		{
-			match: ({ type }) => type === "string",
-			convert: convertString
-		},
-		{
-			match: ({ type }) => type === "number",
-			convert: (ctx) => convertNumeric(ctx, "number")
-		},
-		{
-			match: ({ type }) => type === "integer",
-			convert: (ctx) => convertNumeric(ctx, "integer")
-		},
-		{
-			match: ({ type }) => type === "boolean",
-			convert: convertBoolean
-		},
-		{
-			match: ({ type }) => type === "null",
-			convert: ({ schema, name, nullable }) => createNullSchema(schema, name, nullable)
+	function resolveRefNode(refPath, rawOptions) {
+		if (resolvingRefs.has(refPath)) return null;
+		if (!resolvedRefCache.has(refPath)) {
+			let resolved = null;
+			try {
+				const referenced = resolveRef(document, refPath);
+				if (referenced) {
+					resolvingRefs.add(refPath);
+					resolved = parseSchema({ schema: referenced }, rawOptions);
+					resolvingRefs.delete(refPath);
+				}
+			} catch {}
+			resolvedRefCache.set(refPath, resolved);
 		}
-	];
+		return resolvedRefCache.get(refPath) ?? null;
+	}
 	/**
 	* Converts an OAS `SchemaObject` into a `SchemaNode`.
 	*
@@ -1969,19 +1865,23 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 			schema: flattenedSchema,
 			name
 		}, rawOptions);
-		const nullable = dialect.schema.isNullable(schema) || void 0;
-		const schemaCtx = {
+		const nullable = isNullable(schema) || void 0;
+		const context = {
 			schema,
 			name,
 			nullable,
 			defaultValue: schema.default === null && nullable ? void 0 : schema.default,
 			type: Array.isArray(schema.type) ? schema.type[0] : schema.type,
 			rawOptions,
-			options
+			options,
+			parse: parseSchema,
+			document,
+			resolveRefNode,
+			refExists
 		};
 		for (const rule of schemaRules) {
-			if (!rule.match(schemaCtx)) continue;
-			const node = rule.convert(schemaCtx);
+			if (!rule.match(context)) continue;
+			const node = rule.convert(context);
 			if (node) return node;
 		}
 		const emptyType = options.emptySchemaType;
@@ -2039,7 +1939,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 		const keys = [];
 		for (const key in schema.properties) {
 			const prop = schema.properties[key];
-			if (prop && !dialect.schema.isReference(prop) && prop[flag]) keys.push(key);
+			if (prop && !isReference(prop) && prop[flag]) keys.push(key);
 		}
 		return keys.length ? keys : null;
 	}
@@ -2106,7 +2006,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 			});
 		});
 		const pathItem = document.paths?.[operation.path];
-		const pathItemDoc = pathItem && !dialect.schema.isReference(pathItem) ? pathItem : void 0;
+		const pathItemDoc = pathItem && !isReference(pathItem) ? pathItem : void 0;
 		const pickDoc = (key) => {
 			const own = operation.schema[key];
 			if (typeof own === "string") return own;
@@ -2298,13 +2198,10 @@ const adapterOas = createAdapter((options) => {
 	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;
+		const result = getSchemas(document, { contentType });
+		nameMapping = result.nameMapping;
+		schemasCache.set(document, result.schemas);
+		return result.schemas;
 	}
 	function ensureSchemaParser(document) {
 		const cached = schemaParserCache.get(document);
@@ -2420,7 +2317,7 @@ const adapterOas = createAdapter((options) => {
 			const document = await ensureDocument(source);
 			return parseInput({
 				document,
-				schemas: await ensureSchemas(document),
+				schemas: ensureSchemas(document),
 				parser: ensureSchemaParser(document)
 			});
 		}