@kubb/adapter-oas 5.0.0-beta.84 → 5.0.0-beta.85

package/dist/index.d.ts

@@ -1259,7 +1259,7 @@ type AdapterOasResolvedOptions = {
   enumSuffix: AdapterOasOptions['enumSuffix'];
   /**
    * Map from original `$ref` paths to their collision-resolved schema names.
-   * Populated once the adapter resolves a spec's schemas, on the first `stream()` or `parse()`.
+   * Populated once the adapter resolves a spec's schemas, on the first `parse()`.
    *
    * @example
    * ```ts

package/dist/index.js

@@ -142,6 +142,119 @@ const enumExtensionKeys = ["x-enumNames", "x-enum-varnames"];
 */
 const enumDescriptionKeys = ["x-enumDescriptions", "x-enum-descriptions"];
 //#endregion
+//#region src/discriminator.ts
+/**
+* Maps each child schema name to its discriminator patch data by scanning the given
+* top-level AST schema nodes for union schemas that carry a `discriminatorPropertyName`.
+*
+* Called on a small pre-parsed subset of schemas (only the discriminator parents)
+* rather than on all schemas at once.
+*/
+function buildDiscriminatorChildMap(schemas) {
+	const childMap = /* @__PURE__ */ new Map();
+	for (const schema of schemas) {
+		let unionNode = ast.narrowSchema(schema, "union");
+		if (!unionNode) {
+			const intersectionMembers = ast.narrowSchema(schema, "intersection")?.members;
+			if (intersectionMembers) for (const m of intersectionMembers) {
+				const u = ast.narrowSchema(m, "union");
+				if (u) {
+					unionNode = u;
+					break;
+				}
+			}
+		}
+		if (!unionNode?.discriminatorPropertyName || !unionNode.members) continue;
+		const { discriminatorPropertyName, members } = unionNode;
+		for (const member of members) {
+			const intersectionNode = ast.narrowSchema(member, "intersection");
+			if (!intersectionNode?.members) continue;
+			let refNode = null;
+			let objNode = null;
+			for (const m of intersectionNode.members) {
+				refNode ??= ast.narrowSchema(m, "ref");
+				objNode ??= ast.narrowSchema(m, "object");
+			}
+			if (!refNode?.name || !objNode) continue;
+			const prop = objNode.properties.find((p) => p.name === discriminatorPropertyName);
+			const enumNode = prop ? ast.narrowSchema(prop.schema, "enum") : null;
+			if (!enumNode?.enumValues?.length) continue;
+			const enumValues = enumNode.enumValues.filter((v) => v !== null);
+			if (!enumValues.length) continue;
+			const existing = childMap.get(refNode.name);
+			if (!existing) {
+				childMap.set(refNode.name, {
+					propertyName: discriminatorPropertyName,
+					enumValues: [...enumValues]
+				});
+				continue;
+			}
+			existing.enumValues.push(...enumValues);
+		}
+	}
+	return childMap;
+}
+/**
+* Patches a single top-level `SchemaNode` with its discriminator entry (adds or replaces
+* the discriminant property).
+*/
+function patchDiscriminatorNode(node, entry) {
+	const objectNode = ast.narrowSchema(node, "object");
+	if (!objectNode) return node;
+	const { propertyName, enumValues } = entry;
+	const enumSchema = ast.factory.createSchema({
+		type: "enum",
+		enumValues
+	});
+	const newProp = ast.factory.createProperty({
+		name: propertyName,
+		required: true,
+		schema: enumSchema
+	});
+	const existingIdx = objectNode.properties.findIndex((p) => p.name === propertyName);
+	const newProperties = existingIdx >= 0 ? objectNode.properties.map((p, i) => i === existingIdx ? newProp : p) : [...objectNode.properties, newProp];
+	return {
+		...objectNode,
+		properties: newProperties
+	};
+}
+/**
+* Creates a single-property object schema used as a discriminator literal.
+*
+* @example
+* ```ts
+* createDiscriminantNode({ propertyName: 'type', value: 'dog' })
+* // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
+* ```
+*/
+function createDiscriminantNode({ propertyName, value }) {
+	return ast.factory.createSchema({
+		type: "object",
+		primitive: "object",
+		properties: [ast.factory.createProperty({
+			name: propertyName,
+			schema: ast.factory.createSchema({
+				type: "enum",
+				primitive: "string",
+				enumValues: [value]
+			}),
+			required: true
+		})]
+	});
+}
+/**
+* Returns the discriminator key whose mapping value matches `ref`, or `null` when there is no match.
+*
+* @example
+* ```ts
+* findDiscriminator({ dog: '#/components/schemas/Dog' }, '#/components/schemas/Dog') // 'dog'
+* ```
+*/
+function findDiscriminator(mapping, ref) {
+	if (!mapping || !ref) return null;
+	return Object.entries(mapping).find(([, value]) => value === ref)?.[0] ?? null;
+}
+//#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -430,6 +543,34 @@ function isDiscriminator(obj) {
 	return !!obj && !!record["discriminator"] && typeof record["discriminator"] !== "string";
 }
 //#endregion
+//#region src/mime.ts
+/**
+* MIME type fragments that mark a media type as JSON-like.
+*
+* A content type is JSON when it contains any of these substrings. The `+json` entry catches
+* structured-syntax suffixes such as `application/vnd.api+json`.
+*/
+const jsonMimeFragments = [
+	"application/json",
+	"application/x-json",
+	"text/json",
+	"text/x-json",
+	"+json"
+];
+/**
+* Returns `true` when a media type string is JSON-like.
+*
+* @example
+* ```ts
+* isJsonMimeType('application/json')         // true
+* isJsonMimeType('application/vnd.api+json') // true
+* isJsonMimeType('multipart/form-data')      // false
+* ```
+*/
+function isJsonMimeType(mimeType) {
+	return jsonMimeFragments.some((fragment) => mimeType.includes(fragment));
+}
+//#endregion
 //#region src/refs.ts
 const _refCache = /* @__PURE__ */ new WeakMap();
 /**
@@ -496,179 +637,6 @@ function dereferenceWithRef(document, schema) {
 	return schema;
 }
 //#endregion
-//#region src/dialect.ts
-/**
-* The OpenAPI / Swagger dialect, the default used by `@kubb/adapter-oas`.
-*
-* Implements the spec-agnostic {@link ast.SchemaDialect} contract: it isolates the
-* decisions that differ between specs (nullability, `$ref`, discriminator, binary,
-* ref resolution) so the converter pipeline and dispatch rules stay shared. A
-* future adapter (e.g. AsyncAPI) ships its own dialect, `type: ['null', …]`
-* nullability, no discriminator object, binary via `contentEncoding` and reuses
-* the rest unchanged.
-*
-* Formats (`uuid`, `email`, dates, …) are intentionally NOT here: they are shared
-* JSON Schema vocabulary, so the converters keep that common case.
-*
-* @example
-* ```ts
-* const parser = createSchemaParser(context)             // uses oasDialect
-* const parser = createSchemaParser(context, oasDialect) // explicit
-* ```
-*/
-const oasDialect = ast.defineDialect({
-	name: "oas",
-	schema: {
-		isNullable,
-		isReference,
-		isDiscriminator,
-		isBinary: (schema) => schema.type === "string" && schema.contentMediaType === "application/octet-stream",
-		resolveRef
-	}
-});
-//#endregion
-//#region src/discriminator.ts
-/**
-* Maps each child schema name to its discriminator patch data by scanning the given
-* top-level AST schema nodes for union schemas that carry a `discriminatorPropertyName`.
-*
-* The streaming path calls this on a small pre-parsed subset of schemas (only the
-* discriminator parents) rather than on all schemas at once.
-*/
-function buildDiscriminatorChildMap(schemas) {
-	const childMap = /* @__PURE__ */ new Map();
-	for (const schema of schemas) {
-		let unionNode = ast.narrowSchema(schema, "union");
-		if (!unionNode) {
-			const intersectionMembers = ast.narrowSchema(schema, "intersection")?.members;
-			if (intersectionMembers) for (const m of intersectionMembers) {
-				const u = ast.narrowSchema(m, "union");
-				if (u) {
-					unionNode = u;
-					break;
-				}
-			}
-		}
-		if (!unionNode?.discriminatorPropertyName || !unionNode.members) continue;
-		const { discriminatorPropertyName, members } = unionNode;
-		for (const member of members) {
-			const intersectionNode = ast.narrowSchema(member, "intersection");
-			if (!intersectionNode?.members) continue;
-			let refNode = null;
-			let objNode = null;
-			for (const m of intersectionNode.members) {
-				refNode ??= ast.narrowSchema(m, "ref");
-				objNode ??= ast.narrowSchema(m, "object");
-			}
-			if (!refNode?.name || !objNode) continue;
-			const prop = objNode.properties.find((p) => p.name === discriminatorPropertyName);
-			const enumNode = prop ? ast.narrowSchema(prop.schema, "enum") : null;
-			if (!enumNode?.enumValues?.length) continue;
-			const enumValues = enumNode.enumValues.filter((v) => v !== null);
-			if (!enumValues.length) continue;
-			const existing = childMap.get(refNode.name);
-			if (!existing) {
-				childMap.set(refNode.name, {
-					propertyName: discriminatorPropertyName,
-					enumValues: [...enumValues]
-				});
-				continue;
-			}
-			existing.enumValues.push(...enumValues);
-		}
-	}
-	return childMap;
-}
-/**
-* Patches a single top-level `SchemaNode` with its discriminator entry (adds or replaces
-* the discriminant property). Used by the streaming path to apply patches inline per yield
-* without buffering all schemas.
-*/
-function patchDiscriminatorNode(node, entry) {
-	const objectNode = ast.narrowSchema(node, "object");
-	if (!objectNode) return node;
-	const { propertyName, enumValues } = entry;
-	const enumSchema = ast.factory.createSchema({
-		type: "enum",
-		enumValues
-	});
-	const newProp = ast.factory.createProperty({
-		name: propertyName,
-		required: true,
-		schema: enumSchema
-	});
-	const existingIdx = objectNode.properties.findIndex((p) => p.name === propertyName);
-	const newProperties = existingIdx >= 0 ? objectNode.properties.map((p, i) => i === existingIdx ? newProp : p) : [...objectNode.properties, newProp];
-	return {
-		...objectNode,
-		properties: newProperties
-	};
-}
-/**
-* Creates a single-property object schema used as a discriminator literal.
-*
-* @example
-* ```ts
-* createDiscriminantNode({ propertyName: 'type', value: 'dog' })
-* // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
-* ```
-*/
-function createDiscriminantNode({ propertyName, value }) {
-	return ast.factory.createSchema({
-		type: "object",
-		primitive: "object",
-		properties: [ast.factory.createProperty({
-			name: propertyName,
-			schema: ast.factory.createSchema({
-				type: "enum",
-				primitive: "string",
-				enumValues: [value]
-			}),
-			required: true
-		})]
-	});
-}
-/**
-* Returns the discriminator key whose mapping value matches `ref`, or `null` when there is no match.
-*
-* @example
-* ```ts
-* findDiscriminator({ dog: '#/components/schemas/Dog' }, '#/components/schemas/Dog') // 'dog'
-* ```
-*/
-function findDiscriminator(mapping, ref) {
-	if (!mapping || !ref) return null;
-	return Object.entries(mapping).find(([, value]) => value === ref)?.[0] ?? null;
-}
-//#endregion
-//#region src/mime.ts
-/**
-* MIME type fragments that mark a media type as JSON-like.
-*
-* A content type is JSON when it contains any of these substrings. The `+json` entry catches
-* structured-syntax suffixes such as `application/vnd.api+json`.
-*/
-const jsonMimeFragments = [
-	"application/json",
-	"application/x-json",
-	"text/json",
-	"text/x-json",
-	"+json"
-];
-/**
-* Returns `true` when a media type string is JSON-like.
-*
-* @example
-* ```ts
-* isJsonMimeType('application/json')         // true
-* isJsonMimeType('application/vnd.api+json') // true
-* isJsonMimeType('multipart/form-data')      // false
-* ```
-*/
-function isJsonMimeType(mimeType) {
-	return jsonMimeFragments.some((fragment) => mimeType.includes(fragment));
-}
-//#endregion
 //#region src/operation.ts
 /**
 * Slugifies a path for the `operationId` fallback: non-alphanumerics collapse to single dashes,
@@ -795,8 +763,56 @@ 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`,
+* interpolating any `server.variables` into the URL template.
+*
+* Returns `null` when `server.index` is omitted or out of range.
+*
+* @example Resolve the first server
+* `resolveBaseUrl({ document, server: { index: 0 } })`
+*
+* @example Override a path variable
+* `resolveBaseUrl({ document, server: { index: 0, variables: { version: 'v2' } } })`
+*/
+function resolveBaseUrl({ document, server }) {
+	const index = server?.index;
+	const entry = index !== void 0 ? document.servers?.at(index) : void 0;
+	return entry?.url ? resolveServerUrl(entry, server?.variables) : null;
+}
+/**
 * Replaces `{variable}` placeholders in an OpenAPI server URL with provided values.
 * Resolution order: `overrides[key]` → `variable.default` → left unreplaced.
 * Throws if an override value is not in the variable's `enum` list.
@@ -991,7 +1007,7 @@ function flattenSchema(schema) {
 	if (allOfFragments.some(hasStructuralKeywords)) return schema;
 	const { allOf: _allOf, ...rest } = schema;
 	const merged = rest;
-	for (const fragment of allOfFragments) for (const [key, value] of Object.entries(fragment)) if (merged[key] === void 0) merged[key] = value;
+	for (const fragment of allOfFragments) for (const [key, value] of Object.entries(fragment)) merged[key] ??= value;
 	return merged;
 }
 /**
@@ -2168,7 +2184,7 @@ function refPromotedEnums(node, promoted) {
 //#region src/schemaDiagnostics.ts
 /**
 * Reports the advisory diagnostics (`KUBB_UNSUPPORTED_FORMAT`, `KUBB_DEPRECATED`) for one
-* top-level schema. Walks the node the parser produced during `preScan`, threading the RFC 6901
+* top-level schema. Walks the node the parser produced, threading the RFC 6901
 * pointer as it descends so a nested field reports against its full path
 * (`#/components/schemas/Pet/properties/owner/properties/name`). Refs are not followed, so the
 * resolved schema is reported under its own walk. Reports land in the active build run, are a
@@ -2220,148 +2236,6 @@ function visit(node, pointer) {
 	if (node.type === "union" || node.type === "intersection") for (const [index, member] of (node.members ?? []).entries()) visit(member, `${pointer}/members/${index}`);
 }
 //#endregion
-//#region src/stream.ts
-/**
-* Reads the server URL from the document's `servers` array at `server.index`,
-* interpolating any `server.variables` into the URL template.
-*
-* Returns `null` when `server.index` is omitted or out of range.
-*
-* @example Resolve the first server
-* `resolveBaseUrl({ document, server: { index: 0 } })`
-*
-* @example Override a path variable
-* `resolveBaseUrl({ document, server: { index: 0, variables: { version: 'v2' } } })`
-*/
-function resolveBaseUrl({ document, server }) {
-	const index = server?.index;
-	const entry = index !== void 0 ? document.servers?.at(index) : void 0;
-	return entry?.url ? resolveServerUrl(entry, server?.variables) : null;
-}
-/**
-* Parses every schema once to build the lookup structures that streaming needs upfront.
-*
-* Three things happen in this single pass:
-* - `refAliasMap` records schemas that are pure `$ref` aliases so the streaming pass can inline them.
-* - `enumNames` collects the names of every enum schema so plugins skip re-scanning the stream.
-* - `circularNames` runs cycle detection, which requires all nodes in memory simultaneously.
-*   The `allNodes` array is local and drops out of scope as soon as this function returns.
-*
-* After this call, only `refAliasMap` and `discriminatorChildMap` stay alive in the adapter closure.
-* Both are proportional to the number of aliases or discriminator parents, not total schema count.
-*
-* Each schema is parsed again during the streaming pass. This is intentional.
-* Holding the parsed nodes in memory here would defeat the streaming memory benefit.
-*
-* @example
-* ```ts
-* const { refAliasMap, enumNames, circularNames } = preScan({
-*   schemas,
-*   parseSchema,
-*   parserOptions,
-*   discriminator: 'preserve',
-* })
-* ```
-*/
-function preScan({ schemas, parseSchema, parseOperation, document, parserOptions, discriminator, enums = "inline" }) {
-	const allNodes = [];
-	const refAliasMap = /* @__PURE__ */ new Map();
-	const enumNames = [];
-	const discriminatorParentNodes = [];
-	for (const [name, schema] of Object.entries(schemas)) {
-		const node = parseSchema({
-			schema,
-			name
-		}, parserOptions);
-		allNodes.push(node);
-		reportSchemaDiagnostics({
-			node,
-			name
-		});
-		if (node.type === "ref" && node.name && node.name !== name) refAliasMap.set(name, node);
-		if (ast.narrowSchema(node, ast.schemaTypes.enum) && node.name) enumNames.push(node.name);
-		if (discriminator === "propagate" && (schema.oneOf ?? schema.anyOf) && schema.discriminator?.propertyName) discriminatorParentNodes.push(node);
-	}
-	const circularNames = [...findCircularSchemas(allNodes)];
-	const discriminatorChildMap = discriminatorParentNodes.length > 0 ? buildDiscriminatorChildMap(discriminatorParentNodes) : null;
-	let promotedEnums = null;
-	if (enums === "root" && document && parseOperation) {
-		const operationNodes = [];
-		for (const operation of getOperations(document)) {
-			const operationNode = parseOperation(parserOptions, operation);
-			if (operationNode) operationNodes.push(operationNode);
-		}
-		promotedEnums = collectInlineEnums([...allNodes, ...operationNodes], new Set(Object.keys(schemas)));
-		for (const name of promotedEnums.keys()) enumNames.push(name);
-	}
-	return {
-		refAliasMap,
-		enumNames,
-		circularNames,
-		discriminatorChildMap,
-		promotedEnums
-	};
-}
-/**
-* Creates a lazy `InputNode<true>` from already-resolved adapter state.
-*
-* The schema and operation iterables each start a fresh parse pass on every
-* `[Symbol.asyncIterator]()` call. This lets multiple plugins consume the same
-* stream object independently without sharing a cursor or holding all nodes in memory.
-*
-* Ref aliases in `refAliasMap` are inlined during iteration: an alias entry is replaced
-* with its target's parsed node (but keeps the alias name) so plugins never receive bare `ref` nodes.
-*
-* @example
-* ```ts
-* const streamNode = createInputStream({ schemas, parseSchema, parseOperation, document, parserOptions, refAliasMap, discriminatorChildMap, meta })
-* for await (const schema of streamNode.schemas) {
-*   // each call to for-await restarts from the first schema
-* }
-* ```
-*/
-function createInputStream({ schemas, parseSchema, parseOperation, document, parserOptions, refAliasMap, discriminatorChildMap, promotedEnums, meta }) {
-	const schemasIterable = { [Symbol.asyncIterator]() {
-		return (async function* () {
-			if (promotedEnums) for (const definition of promotedEnums.values()) yield definition;
-			for (const [name, schema] of Object.entries(schemas)) {
-				const alias = refAliasMap.get(name);
-				if (alias?.name && schemas[alias.name]) {
-					const aliasNode = {
-						...parseSchema({
-							schema: schemas[alias.name],
-							name: alias.name
-						}, parserOptions),
-						name
-					};
-					yield promotedEnums ? refPromotedEnums(aliasNode, promotedEnums) : aliasNode;
-					continue;
-				}
-				const parsed = parseSchema({
-					schema,
-					name
-				}, parserOptions);
-				const node = discriminatorChildMap?.get(name) ? patchDiscriminatorNode(parsed, discriminatorChildMap.get(name)) : parsed;
-				yield promotedEnums ? refPromotedEnums(node, promotedEnums) : node;
-			}
-		})();
-	} };
-	const operationsIterable = { [Symbol.asyncIterator]() {
-		return (async function* () {
-			for (const operation of getOperations(document)) {
-				const node = parseOperation(parserOptions, operation);
-				if (node) yield promotedEnums ? refPromotedEnums(node, promotedEnums) : node;
-			}
-		})();
-	} };
-	return ast.factory.createInput({
-		stream: true,
-		schemas: schemasIterable,
-		operations: operationsIterable,
-		meta
-	});
-}
-//#endregion
 //#region src/adapter.ts
 /**
 * The `name` of `@kubb/adapter-oas`, used to identify this adapter in a Kubb config.
@@ -2409,7 +2283,6 @@ const adapterOas = createAdapter((options) => {
 	const documentCache = /* @__PURE__ */ new WeakMap();
 	const schemasCache = /* @__PURE__ */ new WeakMap();
 	const schemaParserCache = /* @__PURE__ */ new WeakMap();
-	const preScanCache = /* @__PURE__ */ new WeakMap();
 	function ensureDocument(source) {
 		const cached = documentCache.get(source);
 		if (cached) return cached;
@@ -2443,35 +2316,57 @@ const adapterOas = createAdapter((options) => {
 		schemaParserCache.set(document, parser);
 		return parser;
 	}
-	function ensurePreScan(document, schemas, parseSchema, parseOperation) {
-		const cached = preScanCache.get(document);
-		if (cached) return cached;
-		const result = preScan({
-			schemas,
-			parseSchema,
-			parseOperation,
-			document,
-			parserOptions,
-			discriminator,
-			enums
-		});
-		preScanCache.set(document, result);
-		return result;
-	}
-	async function createStream(source) {
-		const document = await ensureDocument(source);
-		const schemas = await ensureSchemas(document);
-		const { parseSchema, parseOperation } = ensureSchemaParser(document);
-		const { refAliasMap, enumNames, circularNames, discriminatorChildMap, promotedEnums } = ensurePreScan(document, schemas, parseSchema, parseOperation);
-		return createInputStream({
-			schemas,
-			parseSchema,
-			parseOperation,
-			document,
-			parserOptions,
-			refAliasMap,
-			discriminatorChildMap,
-			promotedEnums,
+	function parseInput({ document, schemas, parser }) {
+		const { parseSchema, parseOperation } = parser;
+		const parsedByName = /* @__PURE__ */ new Map();
+		const refAliasMap = /* @__PURE__ */ new Map();
+		const enumNames = [];
+		const discriminatorParentNodes = [];
+		for (const [name, schema] of Object.entries(schemas)) {
+			const node = parseSchema({
+				schema,
+				name
+			}, parserOptions);
+			parsedByName.set(name, node);
+			reportSchemaDiagnostics({
+				node,
+				name
+			});
+			if (node.type === "ref" && node.name && node.name !== name) refAliasMap.set(name, node);
+			if (narrowSchema(node, "enum") && node.name) enumNames.push(node.name);
+			if (discriminator === "propagate" && (schema.oneOf ?? schema.anyOf) && schema.discriminator?.propertyName) discriminatorParentNodes.push(node);
+		}
+		const circularNames = [...findCircularSchemas([...parsedByName.values()])];
+		const discriminatorChildMap = discriminatorParentNodes.length > 0 ? buildDiscriminatorChildMap(discriminatorParentNodes) : null;
+		const operationNodes = [];
+		for (const operation of getOperations(document)) {
+			const operationNode = parseOperation(parserOptions, operation);
+			if (operationNode) operationNodes.push(operationNode);
+		}
+		let promotedEnums = null;
+		if (enums === "root") {
+			promotedEnums = collectInlineEnums([...parsedByName.values(), ...operationNodes], new Set(Object.keys(schemas)));
+			for (const name of promotedEnums.keys()) enumNames.push(name);
+		}
+		const schemaNodes = promotedEnums ? [...promotedEnums.values()] : [];
+		for (const name of Object.keys(schemas)) {
+			const alias = refAliasMap.get(name);
+			let node;
+			if (alias?.name && parsedByName.has(alias.name)) node = {
+				...parsedByName.get(alias.name),
+				name
+			};
+			else {
+				const parsed = parsedByName.get(name);
+				const child = discriminatorChildMap?.get(name);
+				node = child ? patchDiscriminatorNode(parsed, child) : parsed;
+			}
+			schemaNodes.push(promotedEnums ? refPromotedEnums(node, promotedEnums) : node);
+		}
+		const operations = promotedEnums ? operationNodes.map((node) => refPromotedEnums(node, promotedEnums)) : operationNodes;
+		return ast.factory.createInput({
+			schemas: schemaNodes,
+			operations,
 			meta: {
 				title: document.info?.title,
 				description: document.info?.description,
@@ -2522,15 +2417,13 @@ const adapterOas = createAdapter((options) => {
 			} });
 		},
 		async parse(source) {
-			const streamNode = await createStream(source);
-			const [schemas, operations] = await Promise.all([Array.fromAsync(streamNode.schemas), Array.fromAsync(streamNode.operations)]);
-			return ast.factory.createInput({
-				schemas,
-				operations,
-				meta: streamNode.meta
+			const document = await ensureDocument(source);
+			return parseInput({
+				document,
+				schemas: await ensureSchemas(document),
+				parser: ensureSchemaParser(document)
 			});
-		},
-		stream: createStream
+		}
 	};
 });
 //#endregion