@kubb/adapter-oas 5.0.0-beta.19 → 5.0.0-beta.20

package/dist/index.js

@@ -1,236 +1,12 @@
 import "./chunk--u3MIqq1.js";
+import path from "node:path";
 import { ast, createAdapter } from "@kubb/core";
 import BaseOas from "oas";
-import path from "node:path";
 import { bundle, loadConfig } from "@redocly/openapi-core";
 import OASNormalize from "oas-normalize";
 import swagger2openapi from "swagger2openapi";
 import { isRef } from "oas/types";
 import { matchesMimeType } from "oas/utils";
-//#region src/constants.ts
-/**
-* Default parser options applied when no explicit options are provided.
-*
-* @example
-* ```ts
-* import { DEFAULT_PARSER_OPTIONS } from '@kubb/adapter-oas'
-*
-* const parser = createOasParser(oas)
-* const root = parser.parse({ ...DEFAULT_PARSER_OPTIONS, dateType: 'date' })
-* ```
-*/
-const DEFAULT_PARSER_OPTIONS = {
-	dateType: "string",
-	integerType: "bigint",
-	unknownType: "any",
-	emptySchemaType: "any",
-	enumSuffix: "enum"
-};
-/**
-* JSON-Pointer prefix for schemas declared under `components.schemas` in an OpenAPI document.
-*
-* Used when building or parsing `$ref` strings.
-*
-* @example
-* ```ts
-* `${SCHEMA_REF_PREFIX}Pet` // '#/components/schemas/Pet'
-* ```
-*/
-const SCHEMA_REF_PREFIX = "#/components/schemas/";
-/**
-* OpenAPI version string written into the stub document created during multi-spec merges.
-*/
-const MERGE_OPENAPI_VERSION = "3.0.0";
-/**
-* Fallback `info.title` placed in the stub document when merging multiple API files.
-*/
-const MERGE_DEFAULT_TITLE = "Merged API";
-/**
-* Fallback `info.version` placed in the stub document when merging multiple API files.
-*/
-const MERGE_DEFAULT_VERSION = "1.0.0";
-/**
-* Set of JSON Schema keywords that prevent a schema fragment from being inlined during `allOf` flattening.
-*
-* 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 = new Set([
-	"properties",
-	"items",
-	"additionalProperties",
-	"oneOf",
-	"anyOf",
-	"allOf",
-	"not"
-]);
-/**
-* Static map from OAS `format` strings to Kubb `SchemaType` values.
-*
-* Only formats whose AST type differs from the OAS `type` field appear here.
-* Formats that depend on runtime options (`int64`, `date-time`, `date`, `time`) are handled separately
-* in the parser. `ipv4` and `ipv6` map to their own dedicated schema types; `hostname` and
-* `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",
-	email: "email",
-	"idn-email": "email",
-	uri: "url",
-	"uri-reference": "url",
-	url: "url",
-	ipv4: "ipv4",
-	ipv6: "ipv6",
-	hostname: "url",
-	"idn-hostname": "url",
-	binary: "blob",
-	byte: "blob",
-	int32: "integer",
-	float: "number",
-	double: "number"
-};
-/**
-* 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"];
-/**
-* Maps `'any' | 'unknown' | 'void'` option strings to their `ScalarSchemaType` constant.
-* Replaces a plain object lookup with a `Map` for explicit key membership testing via `.has()`.
-*/
-const typeOptionMap = new Map([
-	["any", ast.schemaTypes.any],
-	["unknown", ast.schemaTypes.unknown],
-	["void", ast.schemaTypes.void]
-]);
-//#endregion
-//#region src/discriminator.ts
-/**
-* Builds a map of child schema names → discriminator patch data by scanning the given
-* top-level AST schema nodes for union schemas that carry a `discriminatorPropertyName`.
-*
-* Extracted from `applyDiscriminatorInheritance` so the streaming path can call it 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;
-			let objNode;
-			for (const m of intersectionNode.members) {
-				refNode ??= ast.narrowSchema(m, "ref");
-				objNode ??= ast.narrowSchema(m, "object");
-			}
-			if (!refNode?.name || !objNode) continue;
-			const prop = objNode.properties.find((p) => p.name === discriminatorPropertyName);
-			const enumNode = prop ? ast.narrowSchema(prop.schema, "enum") : void 0;
-			if (!enumNode?.enumValues?.length) continue;
-			const enumValues = enumNode.enumValues.filter((v) => v !== null);
-			if (!enumValues.length) continue;
-			const existing = childMap.get(refNode.name);
-			if (!existing) {
-				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.createSchema({
-		type: "enum",
-		enumValues
-	});
-	const newProp = ast.createProperty({
-		name: propertyName,
-		required: true,
-		schema: enumSchema
-	});
-	const existingIdx = objectNode.properties.findIndex((p) => p.name === propertyName);
-	const newProperties = existingIdx >= 0 ? objectNode.properties.map((p, i) => i === existingIdx ? newProp : p) : [...objectNode.properties, newProp];
-	return {
-		...objectNode,
-		properties: newProperties
-	};
-}
-/**
-* Injects discriminator enum values into child schemas so they know which value identifies them.
-*
-* Finds every union schema in `input.schemas` that has a `discriminatorPropertyName`, collects the
-* enum value each union member is mapped to, then adds (or replaces) that property on the matching
-* child object schema.
-*
-* Returns a new `InputNode` — the original is never mutated.
-*
-* @example
-* ```ts
-* const { root } = parseOas(document, options)
-* const next = applyDiscriminatorInheritance(root)
-* ```
-*/
-function applyDiscriminatorInheritance(root) {
-	const childMap = buildDiscriminatorChildMap(root.schemas);
-	if (childMap.size === 0) return root;
-	return ast.transform(root, { schema(node, { parent }) {
-		if (parent?.kind !== "Input" || !node.name) return;
-		const entry = childMap.get(node.name);
-		if (!entry) return;
-		return patchDiscriminatorNode(node, entry);
-	} });
-}
-//#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -329,6 +105,30 @@ function mergeDeep(target, source) {
 	return result;
 }
 //#endregion
+//#region ../../internals/utils/src/promise.ts
+/**
+* Returns a wrapper that caches the result of the first invocation and replays
+* it for every subsequent call, ignoring later arguments.
+*
+* Works for sync and async factories — for async, the cached value is the
+* promise itself, so concurrent callers share one in-flight execution and
+* cannot race each other.
+*
+* @example
+* ```ts
+* const loadDocument = once(async (path: string) => parse(await readFile(path)))
+* const a = loadDocument('./a.yaml') // parses
+* const b = loadDocument('./b.yaml') // returns the cached promise from the first call
+* ```
+*/
+function once(factory) {
+	let cache;
+	return (...args) => {
+		if (!cache) cache = { value: factory(...args) };
+		return cache.value;
+	};
+}
+//#endregion
 //#region ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
@@ -578,6 +378,126 @@ var URLPath = class {
 	}
 };
 //#endregion
+//#region src/constants.ts
+/**
+* Default parser options applied when no explicit options are provided.
+*
+* @example
+* ```ts
+* import { DEFAULT_PARSER_OPTIONS } from '@kubb/adapter-oas'
+*
+* const parser = createOasParser(oas)
+* const root = parser.parse({ ...DEFAULT_PARSER_OPTIONS, dateType: 'date' })
+* ```
+*/
+const DEFAULT_PARSER_OPTIONS = {
+	dateType: "string",
+	integerType: "bigint",
+	unknownType: "any",
+	emptySchemaType: "any",
+	enumSuffix: "enum"
+};
+/**
+* JSON-Pointer prefix for schemas declared under `components.schemas` in an OpenAPI document.
+*
+* Used when building or parsing `$ref` strings.
+*
+* @example
+* ```ts
+* `${SCHEMA_REF_PREFIX}Pet` // '#/components/schemas/Pet'
+* ```
+*/
+const SCHEMA_REF_PREFIX = "#/components/schemas/";
+/**
+* OpenAPI version string written into the stub document created during multi-spec merges.
+*/
+const MERGE_OPENAPI_VERSION = "3.0.0";
+/**
+* Fallback `info.title` placed in the stub document when merging multiple API files.
+*/
+const MERGE_DEFAULT_TITLE = "Merged API";
+/**
+* Fallback `info.version` placed in the stub document when merging multiple API files.
+*/
+const MERGE_DEFAULT_VERSION = "1.0.0";
+/**
+* Set of JSON Schema keywords that prevent a schema fragment from being inlined during `allOf` flattening.
+*
+* 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 = new Set([
+	"properties",
+	"items",
+	"additionalProperties",
+	"oneOf",
+	"anyOf",
+	"allOf",
+	"not"
+]);
+/**
+* Static map from OAS `format` strings to Kubb `SchemaType` values.
+*
+* Only formats whose AST type differs from the OAS `type` field appear here.
+* Formats that depend on runtime options (`int64`, `date-time`, `date`, `time`) are handled separately
+* in the parser. `ipv4` and `ipv6` map to their own dedicated schema types; `hostname` and
+* `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",
+	email: "email",
+	"idn-email": "email",
+	uri: "url",
+	"uri-reference": "url",
+	url: "url",
+	ipv4: "ipv4",
+	ipv6: "ipv6",
+	hostname: "url",
+	"idn-hostname": "url",
+	binary: "blob",
+	byte: "blob",
+	int32: "integer",
+	float: "number",
+	double: "number"
+};
+/**
+* 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"];
+/**
+* Maps `'any' | 'unknown' | 'void'` option strings to their `ScalarSchemaType` constant.
+* Replaces a plain object lookup with a `Map` for explicit key membership testing via `.has()`.
+*/
+const typeOptionMap = new Map([
+	["any", ast.schemaTypes.any],
+	["unknown", ast.schemaTypes.unknown],
+	["void", ast.schemaTypes.void]
+]);
+//#endregion
 //#region src/guards.ts
 /**
 * Returns `true` when `doc` is a Swagger 2.0 document (no `openapi` key).
@@ -1885,48 +1805,202 @@ function createSchemaParser(ctx) {
 		parseParameter
 	};
 }
+//#endregion
+//#region src/discriminator.ts
+/**
+* Builds a map of child schema names → discriminator patch data by scanning the given
+* top-level AST schema nodes for union schemas that carry a `discriminatorPropertyName`.
+*
+* Extracted from `applyDiscriminatorInheritance` so the streaming path can call it 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;
+			let objNode;
+			for (const m of intersectionNode.members) {
+				refNode ??= ast.narrowSchema(m, "ref");
+				objNode ??= ast.narrowSchema(m, "object");
+			}
+			if (!refNode?.name || !objNode) continue;
+			const prop = objNode.properties.find((p) => p.name === discriminatorPropertyName);
+			const enumNode = prop ? ast.narrowSchema(prop.schema, "enum") : void 0;
+			if (!enumNode?.enumValues?.length) continue;
+			const enumValues = enumNode.enumValues.filter((v) => v !== null);
+			if (!enumValues.length) continue;
+			const existing = childMap.get(refNode.name);
+			if (!existing) {
+				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.createSchema({
+		type: "enum",
+		enumValues
+	});
+	const newProp = ast.createProperty({
+		name: propertyName,
+		required: true,
+		schema: enumSchema
+	});
+	const existingIdx = objectNode.properties.findIndex((p) => p.name === propertyName);
+	const newProperties = existingIdx >= 0 ? objectNode.properties.map((p, i) => i === existingIdx ? newProp : p) : [...objectNode.properties, newProp];
+	return {
+		...objectNode,
+		properties: newProperties
+	};
+}
+//#endregion
+//#region src/stream.ts
 /**
-* Parses an OpenAPI specification into Kubb's universal `InputNode` AST.
+* Reads the server URL from the document's `servers` array at `serverIndex`,
+* interpolating any `serverVariables` into the URL template.
+*
+* Returns `undefined` when `serverIndex` is omitted or out of range.
 *
-* This is the main entry point for `@kubb/adapter-oas`. It converts OpenAPI/Swagger specs into a spec-agnostic tree
-* that downstream plugins (`plugin-ts`, `plugin-zod`, etc.) consume for code generation. No code is generated here —
-* the tree is a pure data structure representing all schemas and operations.
+* @example Resolve the first server
+* `resolveBaseUrl({ document, serverIndex: 0 })`
+*
+* @example Override a path variable
+* `resolveBaseUrl({ document, serverIndex: 0, serverVariables: { version: 'v2' } })`
+*/
+function resolveBaseUrl({ document, serverIndex, serverVariables }) {
+	const server = serverIndex !== void 0 ? document.servers?.at(serverIndex) : void 0;
+	return server?.url ? resolveServerUrl(server, serverVariables) : void 0;
+}
+/**
+* Parses every schema once to build the lookup structures that streaming needs upfront.
 *
-* Returns the AST root and a `nameMapping` for resolving schema references.
+* 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
-* import { parseOas } from '@kubb/adapter-oas'
-*
-* const document = await parseFromConfig(config)
-* const { root, nameMapping } = parseOas(document, { dateType: 'date', contentType: 'application/json' })
+* const { refAliasMap, enumNames, circularNames } = preScan({
+*   schemas,
+*   parseSchema,
+*   parserOptions,
+*   discriminator: 'strict',
+* })
 * ```
 */
-function parseOas(document, options = {}) {
-	const { contentType, ...parserOptions } = options;
-	const mergedOptions = {
-		...DEFAULT_PARSER_OPTIONS,
-		...parserOptions
-	};
-	const { schemas: schemaObjects, nameMapping } = getSchemas(document, { contentType });
-	const { parseSchema: _parseSchema, parseOperation: _parseOperation } = createSchemaParser({
-		document,
-		contentType
-	});
-	const schemas = Object.entries(schemaObjects).map(([name, schema]) => _parseSchema({
-		schema,
-		name
-	}, mergedOptions));
-	const paths = new BaseOas(document).getPaths();
-	const operations = Object.entries(paths).flatMap(([, methods]) => Object.entries(methods).map(([, operation]) => operation ? _parseOperation(mergedOptions, operation) : null).filter((op) => op !== null));
+function preScan({ schemas, parseSchema, parserOptions, discriminator }) {
+	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);
+		if (node.type === "ref" && node.name && node.name !== name) refAliasMap.set(name, node);
+		if (ast.narrowSchema(node, ast.schemaTypes.enum) && node.name) enumNames.push(node.name);
+		if (discriminator === "inherit" && (schema.oneOf ?? schema.anyOf) && schema.discriminator?.propertyName) discriminatorParentNodes.push(node);
+	}
 	return {
-		root: ast.createInput({
-			schemas,
-			operations
-		}),
-		nameMapping
+		refAliasMap,
+		enumNames,
+		circularNames: [...ast.findCircularSchemas(allNodes)],
+		discriminatorChildMap: discriminatorParentNodes.length > 0 ? buildDiscriminatorChildMap(discriminatorParentNodes) : null
 	};
 }
+/**
+* Creates a lazy `InputStreamNode` 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, baseOas, parserOptions, refAliasMap, discriminatorChildMap, meta })
+* for await (const schema of streamNode.schemas) {
+*   // each call to for-await restarts from the first schema
+* }
+* ```
+*/
+function createInputStream({ schemas, parseSchema, parseOperation, baseOas, parserOptions, refAliasMap, discriminatorChildMap, meta }) {
+	const schemasIterable = { [Symbol.asyncIterator]() {
+		return (async function* () {
+			for (const [name, schema] of Object.entries(schemas)) {
+				const alias = refAliasMap.get(name);
+				if (alias?.name && schemas[alias.name]) {
+					yield {
+						...parseSchema({
+							schema: schemas[alias.name],
+							name: alias.name
+						}, parserOptions),
+						name
+					};
+					continue;
+				}
+				const parsed = parseSchema({
+					schema,
+					name
+				}, parserOptions);
+				yield discriminatorChildMap?.get(name) ? patchDiscriminatorNode(parsed, discriminatorChildMap.get(name)) : parsed;
+			}
+		})();
+	} };
+	const operationsIterable = { [Symbol.asyncIterator]() {
+		return (async function* () {
+			for (const methods of Object.values(baseOas.getPaths())) for (const operation of Object.values(methods)) {
+				if (!operation) continue;
+				const node = parseOperation(parserOptions, operation);
+				if (node) yield node;
+			}
+		})();
+	} };
+	return ast.createStreamInput(schemasIterable, operationsIterable, meta);
+}
 //#endregion
 //#region src/adapter.ts
 /**
@@ -1964,38 +2038,54 @@ const adapterOas = createAdapter((options) => {
 	};
 	let nameMapping = /* @__PURE__ */ new Map();
 	let parsedDocument = null;
-	let schemaObjects = null;
-	let baseOasInstance = null;
-	let schemaParserInstance = null;
-	function resolveBaseURL(document) {
-		const server = serverIndex !== void 0 ? document.servers?.at(serverIndex) : void 0;
-		return server?.url ? resolveServerUrl(server, serverVariables) : void 0;
-	}
-	async function ensureDocument(source) {
-		if (parsedDocument) return parsedDocument;
+	const ensureDocument = once(async (source) => {
 		const fresh = await parseFromConfig(source);
 		if (validate) await validateDocument(fresh);
 		parsedDocument = fresh;
 		return fresh;
-	}
-	async function ensureSchemas(document) {
-		if (!schemaObjects) {
-			const result = getSchemas(document, { contentType });
-			schemaObjects = result.schemas;
-			nameMapping = result.nameMapping;
-		}
-		return schemaObjects;
-	}
-	function ensureBaseOas(document) {
-		if (!baseOasInstance) baseOasInstance = new BaseOas(document);
-		return baseOasInstance;
-	}
-	function ensureSchemaParser(document) {
-		if (!schemaParserInstance) schemaParserInstance = createSchemaParser({
-			document,
-			contentType
+	});
+	const ensureSchemas = once(async (document) => {
+		const result = getSchemas(document, { contentType });
+		nameMapping = result.nameMapping;
+		return result.schemas;
+	});
+	const ensureBaseOas = once((document) => new BaseOas(document));
+	const ensureSchemaParser = once((document) => createSchemaParser({
+		document,
+		contentType
+	}));
+	const ensurePreScan = once((schemas, parseSchema) => preScan({
+		schemas,
+		parseSchema,
+		parserOptions,
+		discriminator
+	}));
+	async function createStream(source) {
+		const document = await ensureDocument(source);
+		const schemas = await ensureSchemas(document);
+		const { parseSchema, parseOperation } = ensureSchemaParser(document);
+		const { refAliasMap, enumNames, circularNames, discriminatorChildMap } = ensurePreScan(schemas, parseSchema);
+		return createInputStream({
+			schemas,
+			parseSchema,
+			parseOperation,
+			baseOas: ensureBaseOas(document),
+			parserOptions,
+			refAliasMap,
+			discriminatorChildMap,
+			meta: {
+				title: document.info?.title,
+				description: document.info?.description,
+				version: document.info?.version,
+				baseURL: resolveBaseUrl({
+					document,
+					serverIndex,
+					serverVariables
+				}),
+				circularNames,
+				enumNames
+			}
 		});
-		return schemaParserInstance;
 	}
 	return {
 		name: "oas",
@@ -2035,81 +2125,20 @@ const adapterOas = createAdapter((options) => {
 			});
 		},
 		async parse(source) {
-			const document = await ensureDocument(source);
-			const { root: parsedRoot, nameMapping: parsedNameMapping } = parseOas(document, {
-				contentType,
-				dateType,
-				integerType,
-				unknownType,
-				emptySchemaType,
-				enumSuffix
-			});
-			const node = discriminator === "inherit" ? applyDiscriminatorInheritance(parsedRoot) : parsedRoot;
-			nameMapping = parsedNameMapping;
+			const streamNode = await createStream(source);
+			const collect = async (iter) => {
+				const out = [];
+				for await (const item of iter) out.push(item);
+				return out;
+			};
+			const [schemas, operations] = await Promise.all([collect(streamNode.schemas), collect(streamNode.operations)]);
 			return ast.createInput({
-				...node,
-				meta: {
-					title: document.info?.title,
-					description: document.info?.description,
-					version: document.info?.version,
-					baseURL: resolveBaseURL(document)
-				}
+				schemas,
+				operations,
+				meta: streamNode.meta
 			});
 		},
-		async count(source) {
-			const document = await ensureDocument(source);
-			const schemas = await ensureSchemas(document);
-			const baseOas = ensureBaseOas(document);
-			const operationCount = Object.values(baseOas.getPaths()).flatMap(Object.values).filter(Boolean).length;
-			return {
-				schemas: Object.keys(schemas).length,
-				operations: operationCount
-			};
-		},
-		async stream(source) {
-			const document = await ensureDocument(source);
-			const schemas = await ensureSchemas(document);
-			const discriminatorChildMap = (() => {
-				if (discriminator !== "inherit") return null;
-				const { parseSchema: _preParser } = ensureSchemaParser(document);
-				const parentNodes = [];
-				for (const [name, schema] of Object.entries(schemas)) if ((schema.oneOf ?? schema.anyOf) && schema.discriminator?.propertyName) parentNodes.push(_preParser({
-					schema,
-					name
-				}, parserOptions));
-				return parentNodes.length > 0 ? buildDiscriminatorChildMap(parentNodes) : null;
-			})();
-			const schemasIterable = { [Symbol.asyncIterator]() {
-				return (async function* () {
-					const { parseSchema: _parseSchema } = ensureSchemaParser(document);
-					for (const [name, schema] of Object.entries(schemas)) {
-						const parsedNode = _parseSchema({
-							schema,
-							name
-						}, parserOptions);
-						const entry = discriminatorChildMap?.get(name);
-						yield entry ? patchDiscriminatorNode(parsedNode, entry) : parsedNode;
-					}
-				})();
-			} };
-			const operationsIterable = { [Symbol.asyncIterator]() {
-				return (async function* () {
-					const { parseOperation: _parseOperation } = ensureSchemaParser(document);
-					const paths = ensureBaseOas(document).getPaths();
-					for (const methods of Object.values(paths)) for (const operation of Object.values(methods)) {
-						if (!operation) continue;
-						const node = _parseOperation(parserOptions, operation);
-						if (node) yield node;
-					}
-				})();
-			} };
-			return ast.createStreamInput(schemasIterable, operationsIterable, {
-				title: document.info?.title,
-				description: document.info?.description,
-				version: document.info?.version,
-				baseURL: resolveBaseURL(document)
-			});
-		}
+		stream: createStream
 	};
 });
 //#endregion