@kubb/ast 5.0.0-beta.53 → 5.0.0-beta.55

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { t as __name } from "./chunk-C0LytTxp.js";
-import { $ as SchemaDialect, $t as httpMethods, A as createFunctionParameter, At as IntersectionSchemaNode, B as createProperty, Bt as TimeSchemaNode, C as UserFileNode, Ct as FileNode, D as createExport, Dt as DateSchemaNode, E as createConst, Et as ArraySchemaNode, F as createOperation, Ft as ScalarSchemaType, G as createText, Gt as CodeNode, H as createSchema, Ht as UrlSchemaNode, I as createOutput, It as SchemaNode, J as update, Jt as JSDocNode, K as createType, Kt as ConstNode, L as createParameter, Lt as SchemaNodeByType, M as createImport, Mt as ObjectSchemaNode, N as createInput, Nt as PrimitiveSchemaType, O as createFile, Ot as DatetimeSchemaNode, P as createJsx, Pt as RefSchemaNode, Q as dispatch, Qt as NodeKind, R as createParameterGroup, Rt as SchemaType, S as DistributiveOmit, St as ExportNode, T as createBreak, Tt as SourceNode, U as createSource, Ut as PropertyNode, V as createResponse, Vt as UnionSchemaNode, W as createStreamInput, Wt as ArrowFunctionNode, X as ParserOptions, Xt as TextNode, Y as InferSchemaNode, Yt as JsxNode, Z as DispatchRule, Zt as TypeNode, _ as Printer, _t as FunctionParamNode, a as createDiscriminantNode, at as InputMeta, b as createPrinterFactory, bt as ParameterGroupNode, c as findCircularSchemas, ct as OutputNode, d as ParentOf, dt as OperationNode, en as schemaTypes, et as defineSchemaDialect, f as Visitor, ft as ResponseNode, g as walk, gt as FunctionNodeType, h as transform, ht as ParameterNode, i as containsCircularRef, it as Node, j as createFunctionParameters, jt as NumberSchemaNode, k as createFunction, kt as EnumSchemaNode, l as isStringType, lt as HttpMethod, m as collect, mt as ParameterLocation, n as caseParams, nt as applyDedupe, o as createOperationParams, ot as InputNode, p as VisitorContext, pt as StatusCode, q as syncOptionality, qt as FunctionNode, r as collectUsedSchemaNames, rt as buildDedupePlan, s as extractStringsFromNodes, st as InputStreamNode, t as OperationParamsResolver, tt as DedupePlan, u as syncSchemaRef, ut as HttpOperationNode, v as PrinterFactoryOptions, vt as FunctionParameterNode, w as createArrowFunction, wt as ImportNode, x as definePrinter, xt as ParamsTypeNode, y as PrinterPartial, yt as FunctionParametersNode, z as createParamsType, zt as StringSchemaNode } from "./types-IHUK_alM.js";
+import { $ as DedupeCanonical, $t as schemaTypes, A as createFunctionParameter, At as NumberSchemaNode, B as createProperty, Bt as UnionSchemaNode, C as UserFileNode, Ct as ImportNode, D as createExport, Dt as DatetimeSchemaNode, E as createConst, Et as DateSchemaNode, F as createOperation, Ft as SchemaNode, G as createText, Gt as ConstNode, H as createSchema, Ht as PropertyNode, I as createOutput, It as SchemaNodeByType, J as update, Jt as JsxNode, K as createType, Kt as FunctionNode, L as createParameter, Lt as SchemaType, M as createImport, Mt as PrimitiveSchemaType, N as createInput, Nt as RefSchemaNode, O as createFile, Ot as EnumSchemaNode, P as createJsx, Pt as ScalarSchemaType, Q as defineSchemaDialect, Qt as httpMethods, R as createParameterGroup, Rt as StringSchemaNode, S as DistributiveOmit, St as FileNode, T as createBreak, Tt as ArraySchemaNode, U as createSource, Ut as ArrowFunctionNode, V as createResponse, Vt as UrlSchemaNode, W as createStreamInput, Wt as CodeNode, X as ParserOptions, Xt as TypeNode, Y as InferSchemaNode, Yt as TextNode, Z as SchemaDialect, Zt as NodeKind, _ as Printer, _t as FunctionParameterNode, a as createDiscriminantNode, at as OutputNode, b as createPrinterFactory, bt as ParamsTypeNode, c as findCircularSchemas, ct as HttpMethod, d as ParentOf, dt as ResponseNode, et as DedupeLookups, f as Visitor, ft as StatusCode, g as walk, gt as FunctionParamNode, h as transform, ht as FunctionNodeType, i as containsCircularRef, it as Node, j as createFunctionParameters, jt as ObjectSchemaNode, k as createFunction, kt as IntersectionSchemaNode, l as isStringType, lt as HttpOperationNode, m as collect, mt as ParameterNode, n as caseParams, nt as applyDedupe, o as createOperationParams, ot as InputMeta, p as VisitorContext, pt as ParameterLocation, q as syncOptionality, qt as JSDocNode, r as collectUsedSchemaNames, rt as buildDedupePlan, s as extractStringsFromNodes, st as InputNode, t as OperationParamsResolver, tt as DedupePlan, u as syncSchemaRef, ut as OperationNode, v as PrinterFactoryOptions, vt as FunctionParametersNode, w as createArrowFunction, wt as SourceNode, x as definePrinter, xt as ExportNode, y as PrinterPartial, yt as ParameterGroupNode, z as createParamsType, zt as TimeSchemaNode } from "./types-BL7RpQAE.js";
 
 //#region src/guards.d.ts
 /**
@@ -68,37 +68,21 @@ declare function isHttpOperationNode(node: OperationNode): node is HttpOperation
  */
 declare const isSchemaNode: (node: unknown) => node is SchemaNode;
 //#endregion
-//#region src/resolvers.d.ts
-/**
- * Collects import entries for all `ref` schema nodes in `node`.
- */
-declare function collectImports<TImport>({
-  node,
-  nameMapping,
-  resolve
-}: {
-  node: SchemaNode;
-  nameMapping: Map<string, string>;
-  resolve: (schemaName: string) => TImport | null;
-}): Array<TImport>;
-//#endregion
 //#region src/signature.d.ts
 /**
- * Computes a deterministic, shape-only signature (a fixed-length content hash) for a schema node.
- *
- * Two schemas share a signature when they are structurally identical, ignoring
- * documentation (`name`, `title`, `description`, `example`, `default`, `deprecated`)
- * and usage-slot flags (`optional`, `nullish`, `readOnly`, `writeOnly`). `nullable`
- * is kept because it changes the produced type. `ref` nodes compare by target name,
- * which also keeps the algorithm terminating on circular shapes.
+ * Computes a deterministic, shape-only signature (a content hash) for a schema node. Two schemas
+ * share a signature when they are structurally identical, ignoring documentation (`name`, `title`,
+ * `description`, `example`, `default`, `deprecated`) and usage-slot flags (`optional`, `nullish`,
+ * `readOnly`, `writeOnly`). `nullable` is kept because it changes the produced type, and `ref`
+ * nodes compare by target name, which also terminates on circular shapes.
  *
  * @example Two enums with different descriptions share a signature
  * ```ts
- * schemaSignature(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
- *   schemaSignature(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
+ * signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
+ *   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
  * ```
  */
-declare function schemaSignature(node: SchemaNode): string;
+declare function signatureOf(node: SchemaNode): string;
 //#endregion
 //#region src/transformers.d.ts
 /**
@@ -154,5 +138,5 @@ declare function mergeAdjacentObjectsLazy(members: Iterable<SchemaNode>): Genera
 declare function simplifyUnion(members: Array<SchemaNode>): Array<SchemaNode>;
 declare function setEnumName(propNode: SchemaNode, parentName: string | null | undefined, propName: string, enumSuffix: string): SchemaNode;
 //#endregion
-export { type ArraySchemaNode, type ArrowFunctionNode, type CodeNode, type ConstNode, type DateSchemaNode, type DatetimeSchemaNode, type DedupePlan, type DispatchRule, type DistributiveOmit, type EnumSchemaNode, type ExportNode, type FileNode, type FunctionNode, type FunctionNodeType, type FunctionParamNode, type FunctionParameterNode, type FunctionParametersNode, type HttpMethod, type HttpOperationNode, type ImportNode, type InferSchemaNode, type InputMeta, type InputNode, type InputStreamNode, type IntersectionSchemaNode, type JSDocNode, type JsxNode, type Node, type NodeKind, type NumberSchemaNode, type ObjectSchemaNode, type OperationNode, type OperationParamsResolver, type OutputNode, type ParameterGroupNode, type ParameterLocation, type ParameterNode, type ParamsTypeNode, type ParentOf, type ParserOptions, type PrimitiveSchemaType, type Printer, type PrinterFactoryOptions, type PrinterPartial, type PropertyNode, type RefSchemaNode, type ResponseNode, type ScalarSchemaType, type SchemaDialect, type SchemaNode, type SchemaNodeByType, type SchemaType, type SourceNode, type StatusCode, type StringSchemaNode, type TextNode, type TimeSchemaNode, type TypeNode, type UnionSchemaNode, type UrlSchemaNode, type UserFileNode, type Visitor, type VisitorContext, applyDedupe, buildDedupePlan, caseParams, collect, collectImports, collectUsedSchemaNames, containsCircularRef, createArrowFunction, createBreak, createConst, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createInput, createJsx, createOperation, createOperationParams, createOutput, createParameter, createParameterGroup, createParamsType, createPrinterFactory, createProperty, createResponse, createSchema, createSource, createStreamInput, createText, createType, definePrinter, defineSchemaDialect, dispatch, extractStringsFromNodes, findCircularSchemas, httpMethods, isHttpOperationNode, isInputNode, isOperationNode, isOutputNode, isSchemaNode, isStringType, mergeAdjacentObjectsLazy, narrowSchema, schemaSignature, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, syncSchemaRef, transform, update, walk };
+export { type ArraySchemaNode, type ArrowFunctionNode, type CodeNode, type ConstNode, type DateSchemaNode, type DatetimeSchemaNode, type DedupeCanonical, type DedupeLookups, type DedupePlan, type DistributiveOmit, type EnumSchemaNode, type ExportNode, type FileNode, type FunctionNode, type FunctionNodeType, type FunctionParamNode, type FunctionParameterNode, type FunctionParametersNode, type HttpMethod, type HttpOperationNode, type ImportNode, type InferSchemaNode, type InputMeta, type InputNode, type IntersectionSchemaNode, type JSDocNode, type JsxNode, type Node, type NodeKind, type NumberSchemaNode, type ObjectSchemaNode, type OperationNode, type OperationParamsResolver, type OutputNode, type ParameterGroupNode, type ParameterLocation, type ParameterNode, type ParamsTypeNode, type ParentOf, type ParserOptions, type PrimitiveSchemaType, type Printer, type PrinterFactoryOptions, type PrinterPartial, type PropertyNode, type RefSchemaNode, type ResponseNode, type ScalarSchemaType, type SchemaDialect, type SchemaNode, type SchemaNodeByType, type SchemaType, type SourceNode, type StatusCode, type StringSchemaNode, type TextNode, type TimeSchemaNode, type TypeNode, type UnionSchemaNode, type UrlSchemaNode, type UserFileNode, type Visitor, type VisitorContext, applyDedupe, buildDedupePlan, caseParams, collect, collectUsedSchemaNames, containsCircularRef, createArrowFunction, createBreak, createConst, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createInput, createJsx, createOperation, createOperationParams, createOutput, createParameter, createParameterGroup, createParamsType, createPrinterFactory, createProperty, createResponse, createSchema, createSource, createStreamInput, createText, createType, definePrinter, defineSchemaDialect, extractStringsFromNodes, findCircularSchemas, httpMethods, isHttpOperationNode, isInputNode, isOperationNode, isOutputNode, isSchemaNode, isStringType, mergeAdjacentObjectsLazy, narrowSchema, schemaTypes, setDiscriminatorEnum, setEnumName, signatureOf, simplifyUnion, syncOptionality, syncSchemaRef, transform, update, walk };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,7 +1,24 @@
 import "./chunk-C0LytTxp.js";
-import { S as visitorDepths, _ as isValidVarName, a as enumPropName, b as isScalarPrimitive, h as trimExtName, o as extractRefName, v as camelCase, x as schemaTypes, y as httpMethods } from "./utils-BIcKgbbc.js";
+import { _ as httpMethods, a as enumPropName, b as visitorDepths, g as camelCase, h as isValidVarName, o as extractRefName, v as isScalarPrimitive, y as schemaTypes } from "./utils-0p8ZO287.js";
 import { hash } from "node:crypto";
 import path from "node:path";
+//#region ../../internals/utils/src/fs.ts
+/**
+* Strips the file extension from a path or file name.
+* Only removes the last `.ext` segment when the dot is not part of a directory name.
+*
+* @example
+* trimExtName('petStore.ts')             // 'petStore'
+* trimExtName('/src/models/pet.ts')      // '/src/models/pet'
+* trimExtName('/project.v2/gen/pet.ts')  // '/project.v2/gen/pet'
+* trimExtName('noExtension')             // 'noExtension'
+*/
+function trimExtName(text) {
+	const dotIndex = text.lastIndexOf(".");
+	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
+	return text;
+}
+//#endregion
 //#region ../../internals/utils/src/promise.ts
 /**
 * Wraps `factory` with a keyed cache backed by the provided store.
@@ -1054,7 +1071,7 @@ function createInput(overrides = {}) {
 	};
 }
 /**
-* Creates an `InputStreamNode` from pre-built `AsyncIterable` sources.
+* Creates a streaming `InputNode<true>` from pre-built `AsyncIterable` sources.
 *
 * @example
 * ```ts
@@ -1677,9 +1694,7 @@ function createJsx(value) {
 //#endregion
 //#region src/signature.ts
 /**
-* The shape-affecting flags shared by every node kind: base primitive, format, and `nullable`.
-* Documentation and usage-slot flags (`optional`/`nullish`/`readOnly`/`writeOnly`) are
-* intentionally excluded, they describe the property slot, not the type.
+* The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.
 */
 function flagsDescriptor(node) {
 	return `${node.primitive ?? ""};${node.format ?? ""};${node.nullable ? 1 : 0}`;
@@ -1752,9 +1767,8 @@ const rangeFields = [{
 	prefix: "mx"
 }];
 /**
-* Maps each schema node `type` to the ordered list of shape-contributing fields.
-* Node types absent from this map (scalar types like boolean, null, any, etc.) fall
-* back to `${type}|${flags}` with no additional fields.
+* Maps each node `type` to its ordered shape-contributing fields. Types absent from the map
+* (boolean, null, any, and other scalars) fall back to `${type}|${flags}`.
 */
 const SHAPE_KEYS = {
 	object: [
@@ -1891,9 +1905,8 @@ function serializeShapeField(field, node, record) {
 	}
 }
 /**
-* Builds the local, shape-only descriptor for a node: its kind, flags, constraints, and its
-* children's signatures. {@link signatureOf} hashes this string. Children contribute their
-* fixed-length signature rather than their own full descriptor, which keeps the result bounded.
+* Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,
+* constraints, and its children's signatures.
 */
 function describeShape(node) {
 	const flags = flagsDescriptor(node);
@@ -1905,22 +1918,23 @@ function describeShape(node) {
 	return parts.join("|");
 }
 /**
-* Persistent hash-consing cache: `SchemaNode` → signature digest, keyed by node identity.
-*
-* A `WeakMap` so entries are released once the node is garbage-collected, and so a node hashed
-* during dedupe planning is not re-hashed when the same tree is rewritten during streaming
-* (where `schemaSignature` and `applyDedupe` would otherwise each walk it from scratch). Reuse
-* across calls is sound because a signature depends only on a node's content, and schema nodes
-* are immutable once created, transforms allocate new objects rather than mutating in place.
+* Node → digest cache, keyed by identity. A `WeakMap` so entries die with the node, and so a tree
+* hashed during dedupe planning is not walked again when it is rewritten during streaming. Reuse
+* is safe because a signature depends only on content, and nodes are immutable once created.
 */
 const signatureCache = /* @__PURE__ */ new WeakMap();
 /**
-* Hash-consing: each node's signature is a fixed-length digest of its local shape plus its
-* children's digests (a Merkle hash). Children contribute their 64-char hash instead of their
-* full nested descriptor, so a signature stays bounded regardless of subtree depth, and the
-* digest is identical across calls because it depends only on content, never on traversal
-* order. This keeps the keys built during planning consistent with the ones recomputed later
-* during streaming. {@link signatureCache} memoizes node → digest across every computation.
+* Computes a deterministic, shape-only signature (a content hash) for a schema node. Two schemas
+* share a signature when they are structurally identical, ignoring documentation (`name`, `title`,
+* `description`, `example`, `default`, `deprecated`) and usage-slot flags (`optional`, `nullish`,
+* `readOnly`, `writeOnly`). `nullable` is kept because it changes the produced type, and `ref`
+* nodes compare by target name, which also terminates on circular shapes.
+*
+* @example Two enums with different descriptions share a signature
+* ```ts
+* signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
+*   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
+* ```
 */
 function signatureOf(node) {
 	const cached = signatureCache.get(node);
@@ -1929,24 +1943,6 @@ function signatureOf(node) {
 	signatureCache.set(node, signature);
 	return signature;
 }
-/**
-* Computes a deterministic, shape-only signature (a fixed-length content hash) for a schema node.
-*
-* Two schemas share a signature when they are structurally identical, ignoring
-* documentation (`name`, `title`, `description`, `example`, `default`, `deprecated`)
-* and usage-slot flags (`optional`, `nullish`, `readOnly`, `writeOnly`). `nullable`
-* is kept because it changes the produced type. `ref` nodes compare by target name,
-* which also keeps the algorithm terminating on circular shapes.
-*
-* @example Two enums with different descriptions share a signature
-* ```ts
-* schemaSignature(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
-*   schemaSignature(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
-* ```
-*/
-function schemaSignature(node) {
-	return signatureOf(node);
-}
 //#endregion
 //#region src/dedupe.ts
 /**
@@ -1968,10 +1964,20 @@ function createRefNode(node, canonical) {
 		example: node.example
 	});
 }
-function applyDedupe(node, canonicalBySignature, skipRootMatch = false) {
-	if (canonicalBySignature.size === 0) return node;
+function applyDedupe(node, plan, skipRootMatch = false) {
+	const { canonicalBySignature, aliasNames } = plan;
+	if (canonicalBySignature.size === 0 && aliasNames.size === 0) return node;
 	const root = node;
 	return transform(node, { schema(schemaNode) {
+		if (schemaNode.type === "ref") {
+			const target = schemaNode.ref ? extractRefName(schemaNode.ref) : schemaNode.name;
+			const canonical = target ? aliasNames.get(target) : void 0;
+			return canonical ? {
+				...schemaNode,
+				name: canonical.name,
+				ref: canonical.ref
+			} : void 0;
+		}
 		const signature = signatureOf(schemaNode);
 		if (skipRootMatch && schemaNode === root) return void 0;
 		const canonical = canonicalBySignature.get(signature);
@@ -1995,9 +2001,11 @@ function cleanDefinition(node, name) {
 * Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
 *
 * A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence
-* is a named top-level schema, that name becomes the canonical (so other top-level duplicates
-* and inline copies turn into references to it). Otherwise a new definition is hoisted using
-* `nameFor`. The plan is then applied per node with {@link applyDedupe}.
+* is a named top-level schema, the first one becomes the canonical (so other top-level
+* duplicates and inline copies turn into references to it). Every other top-level name with
+* the same content is recorded in `aliasNames`, so refs to it can be repointed at the
+* canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied
+* per node with {@link applyDedupe}.
 *
 * @example
 * ```ts
@@ -2019,11 +2027,11 @@ function buildDedupePlan(roots, options) {
 		const group = groups.get(signature);
 		if (group) {
 			group.count++;
-			if (isTopLevel && !group.topLevelName) group.topLevelName = schemaNode.name;
+			if (isTopLevel) group.topLevelNames.push(schemaNode.name);
 		} else groups.set(signature, {
 			count: 1,
 			representative: schemaNode,
-			topLevelName: isTopLevel ? schemaNode.name : void 0
+			topLevelNames: isTopLevel ? [schemaNode.name] : []
 		});
 	}
 	for (const root of roots) {
@@ -2031,14 +2039,18 @@ function buildDedupePlan(roots, options) {
 		for (const schemaNode of collectLazy(root, { schema: (node) => node })) record(schemaNode);
 	}
 	const canonicalBySignature = /* @__PURE__ */ new Map();
+	const aliasNames = /* @__PURE__ */ new Map();
 	const pendingHoists = [];
 	for (const [signature, group] of groups) {
 		if (group.count < minOccurrences) continue;
-		if (group.topLevelName) {
-			canonicalBySignature.set(signature, {
-				name: group.topLevelName,
-				ref: refFor(group.topLevelName)
-			});
+		const [firstName, ...duplicateNames] = group.topLevelNames;
+		if (firstName) {
+			const canonical = {
+				name: firstName,
+				ref: refFor(firstName)
+			};
+			canonicalBySignature.set(signature, canonical);
+			for (const duplicate of duplicateNames) aliasNames.set(duplicate, canonical);
 			continue;
 		}
 		const name = nameFor(group.representative, signature);
@@ -2054,15 +2066,18 @@ function buildDedupePlan(roots, options) {
 	}
 	return {
 		canonicalBySignature,
-		hoisted: pendingHoists.map(({ name, representative }) => cleanDefinition(applyDedupe(representative, canonicalBySignature, true), name))
+		aliasNames,
+		hoisted: pendingHoists.map(({ name, representative }) => cleanDefinition(applyDedupe(representative, {
+			canonicalBySignature,
+			aliasNames
+		}, true), name))
 	};
 }
 //#endregion
 //#region src/dialect.ts
 /**
-* Identity helper that types a {@link SchemaDialect} for an adapter. Like
-* `defineParser`, it adds no runtime behavior, it pins the dialect's type for
-* inference and gives adapter authors a discoverable anchor.
+* Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the
+* dialect's type for inference.
 *
 * @example
 * ```ts
@@ -2080,38 +2095,6 @@ function defineSchemaDialect(dialect) {
 	return dialect;
 }
 //#endregion
-//#region src/dispatch.ts
-/**
-* Walks an ordered list of {@link DispatchRule}s and returns the first node produced.
-*
-* This is the shared backbone for spec adapters (OpenAPI today, AsyncAPI and others later).
-* The contract an adapter follows is intentionally minimal:
-*
-*     context → [rule.match → rule.convert] → node
-*
-* An adapter derives a context from a source spec node, then declares an ordered table of
-* rules mapping spec shapes onto Kubb AST nodes. To add support for a new spec, write a new
-* context type and a new rules table, the traversal here is reused unchanged.
-*
-* Order is significant: earlier rules win, so list higher-precedence or more specific shapes
-* first (e.g. composition keywords before plain `type`). A rule whose `match` returns `true`
-* may still `convert` to `null` to defer to later rules. When no rule produces a node this
-* returns `null`, leaving the caller to apply its own fallback.
-*
-* @example
-* ```ts
-* const node = dispatch(schemaRules, schemaContext) ?? createSchema({ type: fallbackType })
-* ```
-*/
-function dispatch(rules, context) {
-	for (const rule of rules) {
-		if (!rule.match(context)) continue;
-		const node = rule.convert(context);
-		if (node !== null && node !== void 0) return node;
-	}
-	return null;
-}
-//#endregion
 //#region src/printer.ts
 /**
 * Defines a schema printer: a function that takes a `SchemaNode` and emits
@@ -2189,21 +2172,6 @@ function createPrinterFactory(getKey) {
 	};
 }
 //#endregion
-//#region src/resolvers.ts
-/**
-* Collects import entries for all `ref` schema nodes in `node`.
-*/
-function collectImports({ node, nameMapping, resolve }) {
-	return collect(node, { schema(schemaNode) {
-		const schemaRef = narrowSchema(schemaNode, "ref");
-		if (!schemaRef?.ref) return null;
-		const rawName = extractRefName(schemaRef.ref);
-		const result = resolve(nameMapping.get(rawName) ?? rawName);
-		if (!result) return null;
-		return result;
-	} });
-}
-//#endregion
 //#region src/transformers.ts
 /**
 * Replaces a discriminator property's schema with a string enum of allowed values.
@@ -2311,6 +2279,6 @@ function setEnumName(propNode, parentName, propName, enumSuffix) {
 	return propNode;
 }
 //#endregion
-export { applyDedupe, buildDedupePlan, caseParams, collect, collectImports, collectUsedSchemaNames, containsCircularRef, createArrowFunction, createBreak, createConst, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createInput, createJsx, createOperation, createOperationParams, createOutput, createParameter, createParameterGroup, createParamsType, createPrinterFactory, createProperty, createResponse, createSchema, createSource, createStreamInput, createText, createType, definePrinter, defineSchemaDialect, dispatch, extractStringsFromNodes, findCircularSchemas, httpMethods, isHttpOperationNode, isInputNode, isOperationNode, isOutputNode, isSchemaNode, isStringType, mergeAdjacentObjectsLazy, narrowSchema, schemaSignature, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, syncSchemaRef, transform, update, walk };
+export { applyDedupe, buildDedupePlan, caseParams, collect, collectUsedSchemaNames, containsCircularRef, createArrowFunction, createBreak, createConst, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createInput, createJsx, createOperation, createOperationParams, createOutput, createParameter, createParameterGroup, createParamsType, createPrinterFactory, createProperty, createResponse, createSchema, createSource, createStreamInput, createText, createType, definePrinter, defineSchemaDialect, extractStringsFromNodes, findCircularSchemas, httpMethods, isHttpOperationNode, isInputNode, isOperationNode, isOutputNode, isSchemaNode, isStringType, mergeAdjacentObjectsLazy, narrowSchema, schemaTypes, setDiscriminatorEnum, setEnumName, signatureOf, simplifyUnion, syncOptionality, syncSchemaRef, transform, update, walk };
 
 //# sourceMappingURL=index.js.map