@kubb/ast 5.0.0-beta.99 → 5.0.0

package/README.md

@@ -30,15 +30,13 @@ Defines the node tree, visitor pattern, factory functions, and type guards used
 
 | Path                            | Contents                                                                                                          |
 | ------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
-| `@kubb/ast`                     | Runtime: node definitions, guards, visitor, macro engine, string and ref helpers, constants                       |
+| `@kubb/ast`                     | Runtime: node definitions, guards, visitor, macro engine, constants                                               |
 | `ast.factory` (via `@kubb/ast`) | Node constructors (`createSchema`, `createFile`, and friends), the `ts.factory` analogue                          |
 | `@kubb/ast/types`               | Types only: all node interfaces, type aliases, visitor types                                                      |
 | `kubb/kit`                      | Re-exports the `ast` and `factory` namespaces, the way most Kubb code reaches the AST without a direct dependency |
 
 `@kubb/ast` is an internal library. Inside the Kubb ecosystem the whole surface travels on the `ast` namespace from `kubb/kit`, so plugins and generators reach it there instead of depending on this package directly. The examples below import from `@kubb/ast` for clarity; through `kubb/kit` the same calls read as `ast.walk`, `ast.factory.createSchema`, and so on.
 
-The macro presets (`macroDiscriminatorEnum`, `macroSimplifyUnion`, `macroEnumName`) and the string, identifier, and ref helpers live on the root `@kubb/ast` export. They no longer ship as separate `@kubb/ast/macros` and `@kubb/ast/utils` subpaths.
-
 ## Node tree
 
 ```
@@ -94,14 +92,7 @@ const root = createInput({
 ### Visitor
 
 ```ts
-import { walk, transform, collect } from '@kubb/ast'
-
-// Side effects
-await walk(root, {
-  schema(node) {
-    console.log(node.type)
-  },
-})
+import { collectSync, transform } from '@kubb/ast'
 
 // Immutable transformation
 const updated = transform(root, {
@@ -111,7 +102,7 @@ const updated = transform(root, {
 })
 
 // Extraction
-const types = collect<string>(root, {
+const types = collectSync<string>(root, {
   schema(node) {
     return node.type
   },
@@ -135,9 +126,9 @@ function process(node: Node) {
 ### Refs
 
 ```ts
-import { extractRefName } from '@kubb/ast'
+import { resolveRefName } from '@kubb/ast'
 
-extractRefName('#/components/schemas/Pet') // 'Pet'
+resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' }) // 'Pet'
 ```
 
 ## Adding a node

package/dist/index.cjs

@@ -25,7 +25,7 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
@@ -363,33 +363,6 @@ const contentDef = defineNode({
 */
 const createContent = contentDef.create;
 //#endregion
-//#region ../../internals/utils/src/casing.ts
-/**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
-*/
-function toCamelOrPascal(text, pascal) {
-	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-		if (word.length > 1 && word === word.toUpperCase()) return word;
-		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-/**
-* Converts `text` to PascalCase.
-*
-* @example Word boundaries
-* `pascalCase('hello-world') // 'HelloWorld'`
-*
-* @example With a suffix
-* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
-*/
-function pascalCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
-}
-//#endregion
 //#region ../../internals/utils/src/fs.ts
 /**
 * Strips the file extension from a path or file name.
@@ -484,6 +457,17 @@ function extractStringsFromNodes(nodes) {
 }
 //#endregion
 //#region src/utils/combineFileMembers.ts
+const IDENTIFIER_RUN = /[\w$]+/g;
+/**
+* How many imports a file needs before indexing the source beats scanning it once per name.
+*/
+const INDEX_ABOVE_IMPORTS = 128;
+/**
+* Every unbroken run of identifier characters in the source.
+*/
+function collectIdentifiers(source) {
+	return new Set(source.match(IDENTIFIER_RUN));
+}
 function sourceKey(source) {
 	return `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
 }
@@ -578,7 +562,8 @@ function combineExports(exports) {
 */
 function combineImports(imports, exports, source) {
 	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
-	const isUsed = (importName) => !source || source.includes(importName) || exportedNames.has(importName);
+	const identifiers = source && imports.length > INDEX_ABOVE_IMPORTS ? collectIdentifiers(source) : null;
+	const isUsed = (importName) => !source || identifiers?.has(importName) || source.includes(importName) || exportedNames.has(importName);
 	const importNameMemo = /* @__PURE__ */ new Map();
 	const canonicalizeName = (n) => {
 		if (typeof n === "string") return n;
@@ -1097,9 +1082,9 @@ function* getChildren(node, recurse) {
 * context. The result is a replacement node, a collected value, or `undefined`
 * when no callback is registered for the kind.
 *
-* Shared by `transform` and `collectLazy` so node-kind dispatch lives in one place.
+* Shared by `transform` and `collect` so node-kind dispatch lives in one place.
 * `TResult` is the caller's expected return: the same node type for `transform`,
-* the collected value type for `collectLazy`.
+* the collected value type for `collect`.
 */
 function applyVisitor(node, visitor, parent) {
 	const key = VISITOR_KEY_BY_KIND[node.kind];
@@ -1157,12 +1142,12 @@ function transformChildren(node, visitor, recurse) {
 }
 /**
 * Lazy depth-first collection pass. Yields every non-null value returned by
-* the visitor callbacks. Use `collect` for the eager array form.
+* the visitor callbacks. Use `collectSync` for the eager array form.
 *
 * @example Collect every operationId
 * ```ts
 * const ids: string[] = []
-* for (const id of collectLazy<string>(root, {
+* for (const id of collect<string>(root, {
 *   operation(node) {
 *     return node.operationId
 *   },
@@ -1171,7 +1156,7 @@ function transformChildren(node, visitor, recurse) {
 * }
 * ```
 */
-function* collectLazy(node, options) {
+function* collect(node, options) {
 	const { depth, parent, ...visitor } = options;
 	yield* collectNode(node, visitor, (depth ?? visitorDepths.deep) === visitorDepths.deep, parent);
 }
@@ -1186,15 +1171,15 @@ function* collectNode(node, visitor, recurse, parent) {
 *
 * @example Collect every operationId
 * ```ts
-* const ids = collect<string>(root, {
+* const ids = collectSync<string>(root, {
 *   operation(node) {
 *     return node.operationId
 *   },
 * })
 * ```
 */
-function collect(node, options) {
-	return Array.from(collectLazy(node, options));
+function collectSync(node, options) {
+	return Array.from(collect(node, options));
 }
 //#endregion
 //#region src/defineMacro.ts
@@ -1234,7 +1219,7 @@ function chain({ macros, key, node, context }) {
 	for (const macro of macros) {
 		const callback = macro[key];
 		if (!callback) continue;
-		if (macro.when && !macro.when(current)) continue;
+		if (macro.match && !macro.match(current)) continue;
 		const next = callback(current, context);
 		if (next != null) current = next;
 	}
@@ -1361,54 +1346,7 @@ function createPrinter(build) {
 	};
 }
 //#endregion
-//#region src/utils/mergeAdjacentSchemas.ts
-/**
-* Merges a run of adjacent anonymous object members into one. Named or non-object members break the
-* run and pass through unchanged. The merge follows member order, so callers control which members
-* combine by where they place them in the sequence.
-*
-* @example
-* ```ts
-* const merged = [...mergeAdjacentObjectsLazy([objectA, objectB])]
-* ```
-*/
-function* mergeAdjacentObjectsLazy(members) {
-	let acc;
-	for (const member of members) {
-		const objectMember = narrowSchema(member, "object");
-		if (objectMember && !objectMember.name && acc !== void 0) {
-			const accObject = narrowSchema(acc, "object");
-			if (accObject && !accObject.name) {
-				acc = createSchema({
-					...accObject,
-					properties: [...accObject.properties ?? [], ...objectMember.properties ?? []]
-				});
-				continue;
-			}
-		}
-		if (acc !== void 0) yield acc;
-		acc = member;
-	}
-	if (acc !== void 0) yield acc;
-}
-//#endregion
 //#region src/utils/refs.ts
-const plainStringTypes = /* @__PURE__ */ new Set([
-	"string",
-	"uuid",
-	"email",
-	"url",
-	"datetime"
-]);
-/**
-* Returns the last path segment of a reference string.
-*
-* @example
-* `extractRefName('#/components/schemas/Pet') // 'Pet'`
-*/
-function extractRefName(ref) {
-	return ref.split("/").at(-1) ?? ref;
-}
 /**
 * Resolves the emitted name of the schema a ref node points at. Prefers `targetName` (set when
 * the referenced schema was renamed, e.g. to break a collision), then the last segment of `ref`,
@@ -1425,73 +1363,9 @@ function extractRefName(ref) {
 function resolveRefName(node) {
 	if (!node || node.type !== "ref") return null;
 	if (node.targetName) return node.targetName;
-	if (node.ref) return extractRefName(node.ref);
+	if (node.ref) return node.ref.split("/").at(-1) ?? node.ref;
 	return node.name ?? node.schema?.name ?? null;
 }
-/**
-* Builds a PascalCase child schema name by joining a parent name and property name.
-* Returns `null` when there is no parent to nest under.
-*
-* @example Nested under a parent
-* `childName('Order', 'shipping_address') // 'OrderShippingAddress'`
-*
-* @example No parent
-* `childName(undefined, 'params') // null`
-*/
-function childName(parentName, propName) {
-	return parentName ? pascalCase([parentName, propName].join(" ")) : null;
-}
-/**
-* Builds a PascalCase enum name from the parent name, property name, and a suffix, skipping any
-* empty parts.
-*
-* @example
-* `enumPropName('Order', 'status', 'enum') // 'OrderStatusEnum'`
-*/
-function enumPropName(parentName, propName, enumSuffix) {
-	return pascalCase([
-		parentName,
-		propName,
-		enumSuffix
-	].filter(Boolean).join(" "));
-}
-/**
-* Merges a ref node with its resolved schema, giving usage-site fields precedence.
-*
-* Every field set on the ref node except `kind`, `type`, `name`, `ref`, and `schema` overrides the
-* same field in the resolved `node.schema` (for example `description`, `nullable`, `readOnly`,
-* `deprecated`). Fields left `undefined` on the ref do not shadow the resolved schema. Non-ref
-* nodes and refs without a resolved `schema` are returned unchanged.
-*
-* @example
-* ```ts
-* const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
-* const merged = syncSchemaRef(ref) // merges with resolved Pet schema
-* ```
-*/
-function syncSchemaRef(node) {
-	const ref = narrowSchema(node, "ref");
-	if (!ref) return node;
-	if (!ref.schema) return node;
-	const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref;
-	const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== void 0));
-	return createSchema({
-		...ref.schema,
-		...definedOverrides
-	});
-}
-/**
-* Returns `true` when a schema emits as a plain `string` type.
-*
-* Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`
-* types, returns `true` only when `representation` is `'string'` rather than `'date'`.
-*/
-function isStringType(node) {
-	if (plainStringTypes.has(node.type)) return true;
-	const temporal = narrowSchema(node, "date") ?? narrowSchema(node, "time");
-	if (temporal) return temporal.representation !== "date";
-	return false;
-}
 //#endregion
 //#region src/utils/schemaGraph.ts
 /**
@@ -1499,7 +1373,7 @@ function isStringType(node) {
 */
 const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
 	const refs = /* @__PURE__ */ new Set();
-	collect(node, { schema(child) {
+	collectSync(node, { schema(child) {
 		if (child.type === "ref") {
 			const name = resolveRefName(child);
 			if (name) refs.add(name);
@@ -1532,6 +1406,36 @@ function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
 	for (const name of collectSchemaRefs(node)) out.add(name);
 	return out;
 }
+/**
+* Collects the de-duplicated target names of every pointer-carrying ref in a node's subtree, in
+* first-occurrence order. The walk is memoized by node identity, so the subtree is scanned once and
+* `resolver.imports` reads the same result across the ts, zod, and faker plugins instead of
+* re-scanning the same schema per plugin.
+*
+* Only refs that carry a `$ref` pointer count, so a synthesized ref pointing at a sibling in the
+* same file (a union member created by name) is left out. That leaves exactly the set
+* `resolver.imports` emits. This is the ordered, import-facing counterpart to
+* {@link collectReferencedSchemaNames}, which returns an unordered set for graph analysis.
+*
+* @example
+* ```ts
+* collectImportedRefNames(petSchema)
+* // ['Category', 'Tag']
+* ```
+*/
+const collectImportedRefNames = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
+	const seen = /* @__PURE__ */ new Set();
+	const names = [];
+	collectSync(node, { schema(child) {
+		if (child.type !== "ref" || !child.ref) return;
+		const name = resolveRefName(child);
+		if (name && !seen.has(name)) {
+			seen.add(name);
+			names.push(name);
+		}
+	} });
+	return names;
+});
 function computeUsedSchemaNames(operations, schemas) {
 	const schemaMap = /* @__PURE__ */ new Map();
 	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
@@ -1544,7 +1448,7 @@ function computeUsedSchemaNames(operations, schemas) {
 			if (namedSchema) visitSchema(namedSchema);
 		}
 	}
-	for (const op of operations) for (const schema of collectLazy(op, {
+	for (const op of operations) for (const schema of collect(op, {
 		depth: "shallow",
 		schema: (node) => node
 	})) visitSchema(schema);
@@ -1574,12 +1478,24 @@ function collectUsedSchemaNames(operations, schemas) {
 	return computeUsedSchemaNames(operations, schemas);
 }
 const EMPTY_CIRCULAR_SET = /* @__PURE__ */ new Set();
-const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (schemas) => {
-	const graph = /* @__PURE__ */ new Map();
-	for (const schema of schemas) {
-		if (!schema.name) continue;
-		graph.set(schema.name, collectReferencedSchemaNames(schema));
-	}
+/**
+* Finds every schema that takes part in a circular dependency chain in a schema dependency graph
+* that maps each schema name to the names it references directly.
+*
+* Use this when the graph was already collected during another pass (e.g. the adapter's convert
+* walk), so the schema nodes are not swept a second time. `findCircularSchemas` builds the graph
+* from schema nodes and delegates here.
+*
+* @example
+* ```ts
+* const graph = new Map([
+*   ['Pet', new Set(['Category'])],
+*   ['Category', new Set(['Pet'])],
+* ])
+* findCircularSchemasFromGraph(graph) // Set { 'Pet', 'Category' }
+* ```
+*/
+function findCircularSchemasFromGraph(graph) {
 	const circular = /* @__PURE__ */ new Set();
 	for (const start of graph.keys()) {
 		const visited = /* @__PURE__ */ new Set();
@@ -1597,6 +1513,14 @@ const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (schemas)
 		}
 	}
 	return circular;
+}
+const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (schemas) => {
+	const graph = /* @__PURE__ */ new Map();
+	for (const schema of schemas) {
+		if (!schema.name) continue;
+		graph.set(schema.name, collectReferencedSchemaNames(schema));
+	}
+	return findCircularSchemasFromGraph(graph);
 });
 /**
 * Finds every schema that takes part in a circular dependency chain, including direct self-loops.
@@ -1611,174 +1535,6 @@ function findCircularSchemas(schemas) {
 	if (schemas.length === 0) return EMPTY_CIRCULAR_SET;
 	return findCircularSchemasMemo(schemas);
 }
-/**
-* Returns `true` when a schema, or anything nested inside it, references a circular schema.
-*
-* Pass `excludeName` to skip refs to a specific schema, which helps when self-references are handled
-* on their own. Pair it with `findCircularSchemas()` to decide where lazy wrappers go.
-*
-* @note Stops at the first matching circular ref.
-*/
-function containsCircularRef(node, { circularSchemas, excludeName }) {
-	if (!node || circularSchemas.size === 0) return false;
-	for (const _ of collectLazy(node, { schema(child) {
-		if (child.type !== "ref") return null;
-		const name = resolveRefName(child);
-		return name && name !== excludeName && circularSchemas.has(name) ? true : null;
-	} })) return true;
-	return false;
-}
-//#endregion
-//#region src/macros/macroDiscriminatorEnum.ts
-/**
-* Builds a macro that replaces a discriminator property's schema with a string enum of the given
-* values. Object schemas that lack the property are returned unchanged.
-*
-* @example
-* ```ts
-* const macro = macroDiscriminatorEnum({ propertyName: 'type', values: ['dog', 'cat'] })
-* const next = applyMacros(objectSchema, [macro], { depth: 'shallow' })
-* ```
-*/
-function macroDiscriminatorEnum({ propertyName, values, enumName }) {
-	return defineMacro({
-		name: "discriminator-enum",
-		schema(node) {
-			const objectNode = narrowSchema(node, "object");
-			if (!objectNode?.properties?.length) return void 0;
-			if (!objectNode.properties.some((prop) => prop.name === propertyName)) return void 0;
-			return createSchema({
-				...objectNode,
-				properties: objectNode.properties.map((prop) => {
-					if (prop.name !== propertyName) return prop;
-					return createProperty({
-						...prop,
-						schema: createSchema({
-							type: "enum",
-							primitive: "string",
-							enumValues: values,
-							name: enumName,
-							readOnly: prop.schema.readOnly,
-							writeOnly: prop.schema.writeOnly
-						})
-					});
-				})
-			});
-		}
-	});
-}
-//#endregion
-//#region src/macros/macroEnumName.ts
-/**
-* Builds a macro that names an inline enum schema from its parent and property name. Boolean enums
-* are left anonymous. Non-enum nodes are returned unchanged.
-*
-* @example
-* ```ts
-* const macro = macroEnumName({ parentName: 'Pet', propName: 'status', enumSuffix: 'enum' })
-* const named = applyMacros(propSchema, [macro], { depth: 'shallow' })
-* ```
-*/
-function macroEnumName({ parentName, propName, enumSuffix }) {
-	return defineMacro({
-		name: "enum-name",
-		schema(node) {
-			const enumNode = narrowSchema(node, "enum");
-			if (enumNode?.primitive === "boolean") return {
-				...node,
-				name: null
-			};
-			if (enumNode) return {
-				...node,
-				name: enumPropName(parentName, propName, enumSuffix)
-			};
-		}
-	});
-}
-//#endregion
-//#region src/macros/macroRenameSchema.ts
-/**
-* Builds a macro that renames a schema consistently: the declaration (`name`) and every ref
-* pointing at it (`targetName`) change together, so imports and printed references stay in
-* sync. Renaming only one side by hand produces imports for files that are never generated.
-*
-* @example
-* `const macro = macroRenameSchema({ from: 'Order', to: 'StoreOrder' })`
-*/
-function macroRenameSchema({ from, to }) {
-	return defineMacro({
-		name: "rename-schema",
-		schema(node) {
-			const refNode = narrowSchema(node, "ref");
-			if (!refNode) return node.name === from ? {
-				...node,
-				name: to
-			} : void 0;
-			const renamesDeclaration = refNode.name === from;
-			const renamesTarget = resolveRefName(refNode) === from;
-			if (!renamesDeclaration && !renamesTarget) return void 0;
-			return {
-				...refNode,
-				...renamesDeclaration ? { name: to } : {},
-				...renamesTarget ? { targetName: to } : {}
-			};
-		}
-	});
-}
-//#endregion
-//#region src/macros/macroSimplifyUnion.ts
-/**
-* Scalar primitive schema types used for union simplification and type narrowing.
-*/
-const SCALAR_PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
-	"string",
-	"number",
-	"integer",
-	"bigint",
-	"boolean"
-]);
-function isScalarPrimitive(type) {
-	return SCALAR_PRIMITIVE_TYPES.has(type);
-}
-/**
-* Filters union members, dropping enum members that a broader scalar primitive already covers.
-*/
-function simplifyUnionMembers(members) {
-	const scalarPrimitives = new Set(members.filter((member) => isScalarPrimitive(member.type)).map((m) => m.type));
-	if (!scalarPrimitives.size) return members;
-	return members.filter((member) => {
-		const enumNode = narrowSchema(member, "enum");
-		if (!enumNode) return true;
-		const primitive = enumNode.primitive;
-		if (!primitive) return true;
-		if ((enumNode.namedEnumValues?.length ?? enumNode.enumValues?.length ?? 0) <= 1) return true;
-		if (scalarPrimitives.has(primitive)) return false;
-		if ((primitive === "integer" || primitive === "number") && (scalarPrimitives.has("integer") || scalarPrimitives.has("number"))) return false;
-		return true;
-	});
-}
-/**
-* Removes union members a broader scalar primitive already covers, such as a multi-value string enum
-* sitting next to a plain `string`. Single-value enums are kept.
-*
-* @example
-* ```ts
-* const next = applyMacros(unionSchema, [macroSimplifyUnion], { depth: 'shallow' })
-* ```
-*/
-const macroSimplifyUnion = defineMacro({
-	name: "simplify-union",
-	schema(node) {
-		const unionNode = narrowSchema(node, "union");
-		if (!unionNode?.members?.length) return void 0;
-		const simplified = simplifyUnionMembers(unionNode.members);
-		if (simplified.length === unionNode.members.length) return void 0;
-		return {
-			...unionNode,
-			members: simplified
-		};
-	}
-});
 //#endregion
 //#region src/factory.ts
 var factory_exports = /* @__PURE__ */ __exportAll({
@@ -1833,37 +1589,27 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	applyMacros: () => applyMacros,
 	arrowFunctionDef: () => arrowFunctionDef,
 	breakDef: () => breakDef,
-	childName: () => childName,
 	collect: () => collect,
+	collectImportedRefNames: () => collectImportedRefNames,
+	collectSync: () => collectSync,
 	collectUsedSchemaNames: () => collectUsedSchemaNames,
-	combineExports: () => combineExports,
-	combineImports: () => combineImports,
-	combineSources: () => combineSources,
 	composeMacros: () => composeMacros,
 	constDef: () => constDef,
-	containsCircularRef: () => containsCircularRef,
 	contentDef: () => contentDef,
 	createPrinter: () => createPrinter,
 	defineMacro: () => defineMacro,
 	defineNode: () => defineNode,
-	enumPropName: () => enumPropName,
 	exportDef: () => exportDef,
-	extractRefName: () => extractRefName,
 	extractStringsFromNodes: () => extractStringsFromNodes,
 	factory: () => factory_exports,
 	fileDef: () => fileDef,
 	findCircularSchemas: () => findCircularSchemas,
+	findCircularSchemasFromGraph: () => findCircularSchemasFromGraph,
 	functionDef: () => functionDef,
 	importDef: () => importDef,
 	inputDef: () => inputDef,
 	isHttpOperationNode: () => isHttpOperationNode,
-	isStringType: () => isStringType,
 	jsxDef: () => jsxDef,
-	macroDiscriminatorEnum: () => macroDiscriminatorEnum,
-	macroEnumName: () => macroEnumName,
-	macroRenameSchema: () => macroRenameSchema,
-	macroSimplifyUnion: () => macroSimplifyUnion,
-	mergeAdjacentObjectsLazy: () => mergeAdjacentObjectsLazy,
 	narrowSchema: () => narrowSchema,
 	nodeDefs: () => nodeDefs,
 	operationDef: () => operationDef,
@@ -1877,7 +1623,6 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	schemaDef: () => schemaDef,
 	schemaTypes: () => schemaTypes,
 	sourceDef: () => sourceDef,
-	syncSchemaRef: () => syncSchemaRef,
 	textDef: () => textDef,
 	transform: () => transform,
 	typeDef: () => typeDef
@@ -1892,22 +1637,17 @@ Object.defineProperty(exports, "ast", {
 	}
 });
 exports.breakDef = breakDef;
-exports.childName = childName;
 exports.collect = collect;
+exports.collectImportedRefNames = collectImportedRefNames;
+exports.collectSync = collectSync;
 exports.collectUsedSchemaNames = collectUsedSchemaNames;
-exports.combineExports = combineExports;
-exports.combineImports = combineImports;
-exports.combineSources = combineSources;
 exports.composeMacros = composeMacros;
 exports.constDef = constDef;
-exports.containsCircularRef = containsCircularRef;
 exports.contentDef = contentDef;
 exports.createPrinter = createPrinter;
 exports.defineMacro = defineMacro;
 exports.defineNode = defineNode;
-exports.enumPropName = enumPropName;
 exports.exportDef = exportDef;
-exports.extractRefName = extractRefName;
 exports.extractStringsFromNodes = extractStringsFromNodes;
 Object.defineProperty(exports, "factory", {
 	enumerable: true,
@@ -1917,17 +1657,12 @@ Object.defineProperty(exports, "factory", {
 });
 exports.fileDef = fileDef;
 exports.findCircularSchemas = findCircularSchemas;
+exports.findCircularSchemasFromGraph = findCircularSchemasFromGraph;
 exports.functionDef = functionDef;
 exports.importDef = importDef;
 exports.inputDef = inputDef;
 exports.isHttpOperationNode = isHttpOperationNode;
-exports.isStringType = isStringType;
 exports.jsxDef = jsxDef;
-exports.macroDiscriminatorEnum = macroDiscriminatorEnum;
-exports.macroEnumName = macroEnumName;
-exports.macroRenameSchema = macroRenameSchema;
-exports.macroSimplifyUnion = macroSimplifyUnion;
-exports.mergeAdjacentObjectsLazy = mergeAdjacentObjectsLazy;
 exports.narrowSchema = narrowSchema;
 exports.nodeDefs = nodeDefs;
 exports.operationDef = operationDef;
@@ -1941,7 +1676,6 @@ exports.responseDef = responseDef;
 exports.schemaDef = schemaDef;
 exports.schemaTypes = schemaTypes;
 exports.sourceDef = sourceDef;
-exports.syncSchemaRef = syncSchemaRef;
 exports.textDef = textDef;
 exports.transform = transform;
 exports.typeDef = typeDef;