@kubb/ast 5.0.0-beta.57 → 5.0.0-beta.58

package/dist/index.cjs

@@ -1,190 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_utils = require("./utils-cdQ6Pzyi.cjs");
+const require_utils = require("./utils-C8bWAzhv.cjs");
+const require_factory = require("./factory-JN-Ylfl6.cjs");
 let node_crypto = require("node:crypto");
-let node_path = require("node:path");
-node_path = require_utils.__toESM(node_path, 1);
-//#region src/node.ts
-/**
-* Builds a type guard that matches nodes of the given `kind`.
-*/
-function isKind(kind) {
-	return (node) => node.kind === kind;
-}
-/**
-* Updates a schema's `optional` and `nullish` flags from a parent's `required`
-* value and the schema's own `nullable`. Mirrors how OpenAPI parameters and
-* object properties combine "required" and "nullable" into a single AST.
-*
-* - Non-required + non-nullable → `optional: true`.
-* - Non-required + nullable → `nullish: true`.
-* - Required → both flags cleared.
-*/
-function syncOptionality(schema, required) {
-	const nullable = schema.nullable ?? false;
-	return {
-		...schema,
-		optional: !required && !nullable ? true : void 0,
-		nullish: !required && nullable ? true : void 0
-	};
-}
-/**
-* Defines a node once and derives its `create` builder, `is` guard, and traversal
-* metadata. `create` merges `defaults`, the `build` hook (or the raw input), and the
-* `kind`, so node construction lives in one place without scattered `as` casts.
-*
-* Set `rebuild: true` when the `build` hook derives fields from children. After a
-* transform rewrites those children, the registry reruns `create` so the derived
-* fields stay correct.
-*
-* @example Simple node
-* ```ts
-* const importDef = defineNode<ImportNode>({ kind: 'Import' })
-* const createImport = importDef.create
-* ```
-*
-* @example Node with a build hook that is rerun on transform
-* ```ts
-* const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
-*   kind: 'Property',
-*   build: (props) => ({ ...props, required: props.required ?? false }),
-*   children: ['schema'],
-*   visitorKey: 'property',
-*   rebuild: true,
-* })
-* ```
-*/
-function defineNode(config) {
-	const { kind, defaults, build, children, visitorKey, rebuild } = config;
-	function create(input) {
-		const base = build ? build(input) : input;
-		return {
-			...defaults,
-			...base,
-			kind
-		};
-	}
-	return {
-		kind,
-		create,
-		is: isKind(kind),
-		children,
-		visitorKey,
-		rebuild
-	};
-}
-//#endregion
-//#region src/nodes/schema.ts
-/**
-* Maps schema `type` to its underlying `primitive`.
-* Primitive types map to themselves. Special string formats map to `'string'`.
-* Complex types (`ref`, `enum`, `union`, `intersection`, `tuple`, `blob`) are left unset.
-*/
-const TYPE_TO_PRIMITIVE = {
-	string: "string",
-	number: "number",
-	integer: "integer",
-	bigint: "bigint",
-	boolean: "boolean",
-	null: "null",
-	any: "any",
-	unknown: "unknown",
-	void: "void",
-	never: "never",
-	object: "object",
-	array: "array",
-	date: "date",
-	uuid: "string",
-	email: "string",
-	url: "string",
-	datetime: "string",
-	time: "string"
-};
-/**
-* Definition for the {@link SchemaNode}. Object schemas default `properties` to an
-* empty array, and `primitive` is inferred from `type` when not explicitly provided.
-*/
-const schemaDef = defineNode({
-	kind: "Schema",
-	build: (props) => {
-		if (props.type === "object") return {
-			properties: [],
-			primitive: "object",
-			...props
-		};
-		return {
-			primitive: TYPE_TO_PRIMITIVE[props.type],
-			...props
-		};
-	},
-	children: [
-		"properties",
-		"items",
-		"members",
-		"additionalProperties"
-	],
-	visitorKey: "schema"
-});
-function createSchema(props) {
-	return schemaDef.create(props);
-}
-//#endregion
-//#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.
-*
-* Pass a `WeakMap` for object keys (results are GC-eligible when the key is
-* collected) or a `Map` for primitive keys. For multi-argument functions,
-* nest two `memoize` calls — the outer keyed by the first argument, the
-* inner (created once per outer miss) keyed by the second.
-*
-* Because the cache is owned by the caller, it can be shared, inspected, or
-* cleared independently of the memoized function.
-*
-* @example Single WeakMap key
-* ```ts
-* const cache = new WeakMap<SchemaNode, Set<string>>()
-* const getRefs = memoize(cache, (node) => collectRefs(node))
-* ```
-*
-* @example Single Map key (primitive)
-* ```ts
-* const cache = new Map<string, Resolver>()
-* const getResolver = memoize(cache, (name) => buildResolver(name))
-* ```
-*
-* @example Two-level (object + primitive)
-* ```ts
-* const outer = new WeakMap<Params[], Map<string, Params[]>>()
-* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
-* fn(params)('camelcase')
-* ```
-*/
-function memoize(store, factory) {
-	return (key) => {
-		if (store.has(key)) return store.get(key);
-		const value = factory(key);
-		store.set(key, value);
-		return value;
-	};
-}
-//#endregion
 //#region src/signature.ts
 /**
 * The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.
@@ -392,791 +209,49 @@ function serializeShapeField(field, node, record) {
 			let values = "";
 			if (en.namedEnumValues?.length) values = en.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(",");
 			else if (en.enumValues?.length) values = en.enumValues.map((value) => `${value === null ? "null" : typeof value}:${String(value)}`).join(",");
-			return `v[${values}]`;
-		}
-		case "refTarget": return `->${refTargetName(node)}`;
-	}
-}
-/**
-* 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);
-	const fields = SHAPE_KEYS[node.type];
-	if (!fields) return `${node.type}|${flags}`;
-	const record = node;
-	const parts = [`${node.type}|${flags}`];
-	for (const field of fields) parts.push(serializeShapeField(field, node, record));
-	return parts.join("|");
-}
-/**
-* 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();
-/**
-* 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);
-	if (cached !== void 0) return cached;
-	const signature = (0, node_crypto.hash)("sha256", describeShape(node), "hex");
-	signatureCache.set(node, signature);
-	return signature;
-}
-//#endregion
-//#region src/nodes/code.ts
-/**
-* Definition for the {@link ConstNode}.
-*/
-const constDef = defineNode({ kind: "Const" });
-/**
-* Creates a `ConstNode` representing a TypeScript `const` declaration.
-*
-* @example Exported constant with type and `as const`
-* ```ts
-* createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
-* // export const pets: Pet[] = ... as const
-* ```
-*/
-const createConst = constDef.create;
-/**
-* Definition for the {@link TypeNode}.
-*/
-const typeDef = defineNode({ kind: "Type" });
-/**
-* Creates a `TypeNode` representing a TypeScript `type` alias declaration.
-*
-* @example
-* ```ts
-* createType({ name: 'Pet', export: true })
-* // export type Pet = ...
-* ```
-*/
-const createType = typeDef.create;
-/**
-* Definition for the {@link FunctionNode}.
-*/
-const functionDef = defineNode({ kind: "Function" });
-/**
-* Creates a `FunctionNode` representing a TypeScript `function` declaration.
-*
-* @example
-* ```ts
-* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
-* // export async function fetchPet(): Promise<Pet> { ... }
-* ```
-*/
-const createFunction = functionDef.create;
-/**
-* Definition for the {@link ArrowFunctionNode}.
-*/
-const arrowFunctionDef = defineNode({ kind: "ArrowFunction" });
-/**
-* Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
-*
-* @example
-* ```ts
-* createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
-* // export const double = (n: number) => ...
-* ```
-*/
-const createArrowFunction = arrowFunctionDef.create;
-/**
-* Definition for the {@link TextNode}.
-*/
-const textDef = defineNode({
-	kind: "Text",
-	build: (value) => ({ value })
-});
-/**
-* Creates a {@link TextNode} representing a raw string fragment in the source output.
-*
-* @example
-* ```ts
-* createText('return fetch(id)')
-* // { kind: 'Text', value: 'return fetch(id)' }
-* ```
-*/
-const createText = textDef.create;
-/**
-* Definition for the {@link BreakNode}.
-*/
-const breakDef = defineNode({
-	kind: "Break",
-	build: () => ({})
-});
-/**
-* Creates a {@link BreakNode} representing a line break in the source output.
-*
-* @example
-* ```ts
-* createBreak()
-* // { kind: 'Break' }
-* ```
-*/
-function createBreak() {
-	return breakDef.create();
-}
-/**
-* Definition for the {@link JsxNode}.
-*/
-const jsxDef = defineNode({
-	kind: "Jsx",
-	build: (value) => ({ value })
-});
-/**
-* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
-*
-* @example
-* ```ts
-* createJsx('<>\n  <a href={href}>Open</a>\n</>')
-* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
-* ```
-*/
-const createJsx = jsxDef.create;
-//#endregion
-//#region src/nodes/content.ts
-/**
-* Definition for the {@link ContentNode}.
-*/
-const contentDef = defineNode({
-	kind: "Content",
-	children: ["schema"]
-});
-/**
-* Creates a `ContentNode` for a single request-body or response content type.
-*/
-const createContent = contentDef.create;
-//#endregion
-//#region src/nodes/file.ts
-/**
-* Definition for the {@link ImportNode}.
-*/
-const importDef = defineNode({ kind: "Import" });
-/**
-* Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
-*
-* @example Named import
-* ```ts
-* createImport({ name: ['useState'], path: 'react' })
-* // import { useState } from 'react'
-* ```
-*/
-const createImport = importDef.create;
-/**
-* Definition for the {@link ExportNode}.
-*/
-const exportDef = defineNode({ kind: "Export" });
-/**
-* Creates an `ExportNode` representing a language-agnostic export/public API declaration.
-*
-* @example Named export
-* ```ts
-* createExport({ name: ['Pet'], path: './Pet' })
-* // export { Pet } from './Pet'
-* ```
-*/
-const createExport = exportDef.create;
-/**
-* Definition for the {@link SourceNode}.
-*/
-const sourceDef = defineNode({ kind: "Source" });
-/**
-* Creates a `SourceNode` representing a fragment of source code within a file.
-*
-* @example
-* ```ts
-* createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
-* ```
-*/
-const createSource = sourceDef.create;
-/**
-* Definition for the {@link FileNode}. The fully resolved builder lives in
-* `createFile`, so this definition only supplies the guard.
-*/
-const fileDef = defineNode({ kind: "File" });
-//#endregion
-//#region src/nodes/function.ts
-/**
-* Definition for the {@link TypeLiteralNode}.
-*/
-const typeLiteralDef = defineNode({ kind: "TypeLiteral" });
-/**
-* Creates a {@link TypeLiteralNode} representing an inline anonymous object type.
-*
-* @example
-* ```ts
-* createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
-* // { petId: string }
-* ```
-*/
-const createTypeLiteral = typeLiteralDef.create;
-/**
-* Definition for the {@link IndexedAccessTypeNode}.
-*/
-const indexedAccessTypeDef = defineNode({ kind: "IndexedAccessType" });
-/**
-* Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
-*
-* @example
-* ```ts
-* createIndexedAccessType({ objectType: 'DeletePetPathParams', indexType: 'petId' })
-* // DeletePetPathParams['petId']
-* ```
-*/
-const createIndexedAccessType = indexedAccessTypeDef.create;
-/**
-* Definition for the {@link ObjectBindingPatternNode}.
-*/
-const objectBindingPatternDef = defineNode({ kind: "ObjectBindingPattern" });
-/**
-* Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
-*
-* @example
-* ```ts
-* createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
-* // { id, name }
-* ```
-*/
-const createObjectBindingPattern = objectBindingPatternDef.create;
-/**
-* Definition for the {@link FunctionParameterNode}. `optional` defaults to `false`.
-* Passing `properties` builds a destructured group: an {@link ObjectBindingPatternNode} name
-* paired with a {@link TypeLiteralNode} type.
-*/
-const functionParameterDef = defineNode({
-	kind: "FunctionParameter",
-	build: (input) => {
-		if ("properties" in input) return {
-			name: createObjectBindingPattern({ elements: input.properties.map((p) => ({ name: p.name })) }),
-			type: createTypeLiteral({ members: input.properties.map((p) => ({
-				name: p.name,
-				type: p.type,
-				optional: p.optional ?? false
-			})) }),
-			optional: input.optional ?? false,
-			...input.default !== void 0 ? { default: input.default } : {}
-		};
-		return {
-			optional: false,
-			...input
-		};
-	}
-});
-/**
-* Creates a `FunctionParameterNode`. `optional` defaults to `false`.
-*
-* @example Optional param
-* ```ts
-* createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
-* // → params?: QueryParams
-* ```
-*
-* @example Destructured group
-* ```ts
-* createFunctionParameter({ properties: [{ name: 'id', type: 'string' }, { name: 'name', type: 'string', optional: true }], default: '{}' })
-* // → { id, name }: { id: string; name?: string } = {}
-* ```
-*/
-const createFunctionParameter = functionParameterDef.create;
-/**
-* Definition for the {@link FunctionParametersNode}.
-*/
-const functionParametersDef = defineNode({
-	kind: "FunctionParameters",
-	defaults: { params: [] }
-});
-/**
-* Creates a `FunctionParametersNode` from an ordered list of parameters.
-*
-* @example
-* ```ts
-* const empty = createFunctionParameters()
-* // { kind: 'FunctionParameters', params: [] }
-* ```
-*/
-function createFunctionParameters(props = {}) {
-	return functionParametersDef.create(props);
-}
-//#endregion
-//#region src/nodes/input.ts
-/**
-* Definition for the {@link InputNode}.
-*/
-const inputDef = defineNode({
-	kind: "Input",
-	defaults: {
-		schemas: [],
-		operations: [],
-		meta: {
-			circularNames: [],
-			enumNames: []
-		}
-	},
-	children: ["schemas", "operations"],
-	visitorKey: "input"
-});
-/**
-* Creates an `InputNode` with stable defaults for `schemas` and `operations`.
-*
-* @example
-* ```ts
-* const input = createInput()
-* // { kind: 'Input', schemas: [], operations: [] }
-* ```
-*/
-function createInput(overrides = {}) {
-	return inputDef.create(overrides);
-}
-/**
-* Creates a streaming `InputNode<true>` from pre-built `AsyncIterable` sources.
-*
-* @example
-* ```ts
-* const node = createStreamInput(schemasIterable, operationsIterable, { title: 'My API' })
-* ```
-*/
-function createStreamInput(schemas, operations, meta) {
-	return {
-		kind: "Input",
-		schemas,
-		operations,
-		meta
-	};
-}
-//#endregion
-//#region src/nodes/requestBody.ts
-/**
-* Definition for the {@link RequestBodyNode}, normalizing each content entry into a `ContentNode`.
-*/
-const requestBodyDef = defineNode({
-	kind: "RequestBody",
-	build: (props) => ({
-		...props,
-		content: props.content?.map(createContent)
-	}),
-	children: ["content"]
-});
-/**
-* Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
-*/
-const createRequestBody = requestBodyDef.create;
-//#endregion
-//#region src/nodes/operation.ts
-/**
-* Definition for the {@link OperationNode}. HTTP operations (those carrying both
-* `method` and `path`) are tagged with `protocol: 'http'`, and the request body is
-* normalized into a `RequestBodyNode`.
-*/
-const operationDef = defineNode({
-	kind: "Operation",
-	build: (props) => {
-		const { requestBody, ...rest } = props;
-		const isHttp = rest.method !== void 0 && rest.path !== void 0;
-		return {
-			tags: [],
-			parameters: [],
-			responses: [],
-			...rest,
-			...isHttp ? { protocol: "http" } : {},
-			requestBody: requestBody ? createRequestBody(requestBody) : void 0
-		};
-	},
-	children: [
-		"parameters",
-		"requestBody",
-		"responses"
-	],
-	visitorKey: "operation"
-});
-function createOperation(props) {
-	return operationDef.create(props);
-}
-//#endregion
-//#region src/nodes/output.ts
-/**
-* Definition for the {@link OutputNode}.
-*/
-const outputDef = defineNode({
-	kind: "Output",
-	defaults: { files: [] },
-	visitorKey: "output"
-});
-/**
-* Creates an `OutputNode` with a stable default for `files`.
-*
-* @example
-* ```ts
-* const output = createOutput()
-* // { kind: 'Output', files: [] }
-* ```
-*/
-function createOutput(overrides = {}) {
-	return outputDef.create(overrides);
-}
-//#endregion
-//#region src/nodes/parameter.ts
-/**
-* Definition for the {@link ParameterNode}. `required` defaults to `false` and the
-* schema's `optional`/`nullish` flags are kept in sync with it.
-*/
-const parameterDef = defineNode({
-	kind: "Parameter",
-	build: (props) => {
-		const required = props.required ?? false;
-		return {
-			...props,
-			required,
-			schema: syncOptionality(props.schema, required)
-		};
-	},
-	children: ["schema"],
-	visitorKey: "parameter",
-	rebuild: true
-});
-/**
-* Creates a `ParameterNode`.
-*
-* @example
-* ```ts
-* const param = createParameter({
-*   name: 'petId',
-*   in: 'path',
-*   required: true,
-*   schema: createSchema({ type: 'string' }),
-* })
-* ```
-*/
-const createParameter = parameterDef.create;
-//#endregion
-//#region src/nodes/property.ts
-/**
-* Definition for the {@link PropertyNode}. `required` defaults to `false` and the
-* schema's `optional`/`nullish` flags are kept in sync with it.
-*/
-const propertyDef = defineNode({
-	kind: "Property",
-	build: (props) => {
-		const required = props.required ?? false;
-		return {
-			...props,
-			required,
-			schema: syncOptionality(props.schema, required)
-		};
-	},
-	children: ["schema"],
-	visitorKey: "property",
-	rebuild: true
-});
-/**
-* Creates a `PropertyNode`.
-*
-* @example
-* ```ts
-* const property = createProperty({
-*   name: 'status',
-*   required: true,
-*   schema: createSchema({ type: 'string', nullable: true }),
-* })
-* // required=true, no optional/nullish
-* ```
-*/
-const createProperty = propertyDef.create;
-//#endregion
-//#region src/nodes/response.ts
-/**
-* Definition for the {@link ResponseNode}. A single legacy `schema` (with optional
-* `mediaType`/`keysToOmit`) is normalized into one `content` entry.
-*/
-const responseDef = defineNode({
-	kind: "Response",
-	build: (props) => {
-		const { schema, mediaType, keysToOmit, content, ...rest } = props;
-		const entries = content ?? (schema ? [{
-			contentType: mediaType ?? "application/json",
-			schema,
-			keysToOmit: keysToOmit ?? null
-		}] : void 0);
-		return {
-			...rest,
-			content: entries?.map(createContent)
-		};
-	},
-	children: ["content"],
-	visitorKey: "response"
-});
-/**
-* Creates a `ResponseNode`.
-*
-* @example
-* ```ts
-* const response = createResponse({
-*   statusCode: '200',
-*   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
-* })
-* ```
-*/
-const createResponse = responseDef.create;
-//#endregion
-//#region src/registry.ts
-/**
-* Every node definition. Adding a node means adding its `defineNode` to one
-* `nodes/*.ts` file and listing it here. The visitor tables below derive from it.
-*/
-const nodeDefs = [
-	inputDef,
-	outputDef,
-	operationDef,
-	requestBodyDef,
-	contentDef,
-	responseDef,
-	schemaDef,
-	propertyDef,
-	parameterDef,
-	functionParameterDef,
-	functionParametersDef,
-	typeLiteralDef,
-	indexedAccessTypeDef,
-	objectBindingPatternDef,
-	constDef,
-	typeDef,
-	functionDef,
-	arrowFunctionDef,
-	textDef,
-	breakDef,
-	jsxDef,
-	importDef,
-	exportDef,
-	sourceDef,
-	fileDef
-];
-/**
-* Child node fields per node kind, in traversal order (Babel's `VISITOR_KEYS`).
-* Derived from each definition's `children`.
-*/
-const VISITOR_KEYS = Object.fromEntries(nodeDefs.flatMap((def) => def.children ? [[def.kind, def.children]] : []));
-/**
-* Maps a node kind to the matching visitor callback name. Derived from each
-* definition's `visitorKey`.
-*/
-const VISITOR_KEY_BY_KIND = Object.fromEntries(nodeDefs.flatMap((def) => def.visitorKey ? [[def.kind, def.visitorKey]] : []));
-/**
-* Per-kind builders rerun after children are rebuilt. Derived from each
-* definition's `rebuild` flag.
-*/
-const nodeRebuilders = Object.fromEntries(nodeDefs.flatMap((def) => def.rebuild ? [[def.kind, def.create]] : []));
-//#endregion
-//#region src/visitor.ts
-/**
-* Creates a small async concurrency limiter.
-*
-* At most `concurrency` tasks are in flight at once. Extra tasks are queued.
-*
-* @example
-* ```ts
-* const limit = createLimit(2)
-* for (const task of [taskA, taskB, taskC]) {
-*   await limit(() => task())
-* }
-* // only 2 tasks run at the same time
-* ```
-*/
-function createLimit(concurrency) {
-	let active = 0;
-	const queue = [];
-	function next() {
-		if (active < concurrency && queue.length > 0) {
-			active++;
-			queue.shift()();
-		}
-	}
-	return function limit(fn) {
-		return new Promise((resolve, reject) => {
-			queue.push(() => {
-				Promise.resolve(fn()).then(resolve, reject).finally(() => {
-					active--;
-					next();
-				});
-			});
-			next();
-		});
-	};
-}
-const visitorKeysByKind = VISITOR_KEYS;
-/**
-* Returns `true` when `value` is an AST node (an object carrying a `kind`).
-*/
-function isNode(value) {
-	return typeof value === "object" && value !== null && "kind" in value;
-}
-/**
-* Returns the immediate traversable children of `node` based on {@link VISITOR_KEYS}.
-*
-* `Schema` children are only included when `recurse` is `true`. Shallow mode skips them.
-*
-* @example
-* ```ts
-* const children = getChildren(operationNode, true)
-* // returns parameters, the request body, and responses
-* ```
-*/
-function* getChildren(node, recurse) {
-	if (node.kind === "Schema" && !recurse) return;
-	const keys = visitorKeysByKind[node.kind];
-	if (!keys) return;
-	const record = node;
-	for (const key of keys) {
-		const value = record[key];
-		if (Array.isArray(value)) {
-			for (const item of value) if (isNode(item)) yield item;
-		} else if (isNode(value)) yield value;
+			return `v[${values}]`;
+		}
+		case "refTarget": return `->${refTargetName(node)}`;
 	}
 }
 /**
-* Invokes the visitor callback that matches `node.kind`, passing the traversal
-* context. Returns the callback's result (a replacement node, a collected
-* value, or `undefined` when no callback is registered for the kind).
-*
-* Shared by `walk`, `transform`, and `collectLazy` 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`, ignored for `walk`.
-*/
-function applyVisitor(node, visitor, parent) {
-	const key = VISITOR_KEY_BY_KIND[node.kind];
-	if (!key) return void 0;
-	const fn = visitor[key];
-	return fn?.(node, { parent });
-}
-/**
-* Async depth-first traversal for side effects. Visitor return values are
-* ignored. Use `transform` when you want to rewrite nodes.
-*
-* Sibling nodes at each depth run concurrently up to `options.concurrency`
-* (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor
-* work. Lower values reduce memory pressure.
-*
-* @example Log every operation
-* ```ts
-* await walk(root, {
-*   operation(node) {
-*     console.log(node.operationId)
-*   },
-* })
-* ```
-*
-* @example Only visit the root node
-* ```ts
-* await walk(root, { depth: 'shallow', input: () => {} })
-* ```
-*/
-async function walk(node, options) {
-	return _walk(node, options, (options.depth ?? require_utils.visitorDepths.deep) === require_utils.visitorDepths.deep, createLimit(options.concurrency ?? 30), void 0);
-}
-async function _walk(node, visitor, recurse, limit, parent) {
-	await limit(() => applyVisitor(node, visitor, parent));
-	const children = Array.from(getChildren(node, recurse));
-	if (children.length === 0) return;
-	await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit, node)));
-}
-function transform(node, options) {
-	const { depth, parent, ...visitor } = options;
-	const recurse = (depth ?? require_utils.visitorDepths.deep) === require_utils.visitorDepths.deep;
-	const rebuilt = transformChildren(applyVisitor(node, visitor, parent) ?? node, options, recurse);
-	if (rebuilt === node) return node;
-	const rebuild = nodeRebuilders[rebuilt.kind];
-	return rebuild ? rebuild(rebuilt) : rebuilt;
-}
-/**
-* Immutably rebuilds a node's children using {@link VISITOR_KEYS}, transforming
-* each child node and leaving non-node values (e.g. `additionalProperties: true`) intact.
-* `Schema` children are skipped in shallow mode.
+* Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,
+* constraints, and its children's signatures.
 */
-function transformChildren(node, options, recurse) {
-	if (node.kind === "Schema" && !recurse) return node;
-	const keys = visitorKeysByKind[node.kind];
-	if (!keys) return node;
+function describeShape(node) {
+	const flags = flagsDescriptor(node);
+	const fields = SHAPE_KEYS[node.type];
+	if (!fields) return `${node.type}|${flags}`;
 	const record = node;
-	const childOptions = {
-		...options,
-		parent: node
-	};
-	let updates;
-	for (const key of keys) {
-		if (!(key in record)) continue;
-		const value = record[key];
-		if (Array.isArray(value)) {
-			let changed = false;
-			const mapped = value.map((item) => {
-				if (!isNode(item)) return item;
-				const next = transform(item, childOptions);
-				if (next !== item) changed = true;
-				return next;
-			});
-			if (changed) (updates ??= {})[key] = mapped;
-		} else if (isNode(value)) {
-			const next = transform(value, childOptions);
-			if (next !== value) (updates ??= {})[key] = next;
-		}
-	}
-	return updates ? {
-		...node,
-		...updates
-	} : node;
+	const parts = [`${node.type}|${flags}`];
+	for (const field of fields) parts.push(serializeShapeField(field, node, record));
+	return parts.join("|");
 }
 /**
-* Lazy depth-first collection pass. Yields every non-null value returned by
-* the visitor callbacks. Use `collect` for the eager array form.
-*
-* @example Collect every operationId
-* ```ts
-* const ids: string[] = []
-* for (const id of collectLazy<string>(root, {
-*   operation(node) {
-*     return node.operationId
-*   },
-* })) {
-*   ids.push(id)
-* }
-* ```
+* 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.
 */
-function* collectLazy(node, options) {
-	const { depth, parent, ...visitor } = options;
-	const recurse = (depth ?? require_utils.visitorDepths.deep) === require_utils.visitorDepths.deep;
-	const v = applyVisitor(node, visitor, parent);
-	if (v != null) yield v;
-	for (const child of getChildren(node, recurse)) yield* collectLazy(child, {
-		...options,
-		parent: node
-	});
-}
+const signatureCache = /* @__PURE__ */ new WeakMap();
 /**
-* Eager depth-first collection pass. Returns an array of every non-null value
-* the visitor callbacks return.
+* 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 Collect every operationId
+* @example Two enums with different descriptions share a signature
 * ```ts
-* const ids = collect<string>(root, {
-*   operation(node) {
-*     return node.operationId
-*   },
-* })
+* signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
+*   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
 * ```
 */
-function collect(node, options) {
-	return Array.from(collectLazy(node, options));
+function signatureOf(node) {
+	const cached = signatureCache.get(node);
+	if (cached !== void 0) return cached;
+	const signature = (0, node_crypto.hash)("sha256", describeShape(node), "hex");
+	signatureCache.set(node, signature);
+	return signature;
 }
 //#endregion
 //#region src/dedupe.ts
@@ -1185,7 +260,7 @@ function collect(node, options) {
 * usage-slot and documentation fields that are not part of the canonical type.
 */
 function createRefNode(node, canonical) {
-	return createSchema({
+	return require_utils.createSchema({
 		type: "ref",
 		name: canonical.name,
 		ref: canonical.ref,
@@ -1203,7 +278,7 @@ 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) {
+	return require_utils.transform(node, { schema(schemaNode) {
 		if (schemaNode.type === "ref") {
 			const target = schemaNode.ref ? require_utils.extractRefName(schemaNode.ref) : schemaNode.name;
 			const canonical = target ? aliasNames.get(target) : void 0;
@@ -1271,7 +346,7 @@ function buildDedupePlan(roots, options) {
 	}
 	for (const root of roots) {
 		if (root.kind === "Schema") topLevelNodes.add(root);
-		for (const schemaNode of collectLazy(root, { schema: (node) => node })) record(schemaNode);
+		for (const schemaNode of require_utils.collectLazy(root, { schema: (node) => node })) record(schemaNode);
 	}
 	const canonicalBySignature = /* @__PURE__ */ new Map();
 	const aliasNames = /* @__PURE__ */ new Map();
@@ -1330,714 +405,6 @@ function defineSchemaDialect(dialect) {
 	return dialect;
 }
 //#endregion
-//#region src/guards.ts
-/**
-* Narrows a `SchemaNode` to the variant that matches `type`.
-*
-* @example
-* ```ts
-* const schema = createSchema({ type: 'string' })
-* const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
-* ```
-*/
-function narrowSchema(node, type) {
-	return node?.type === type ? node : null;
-}
-/**
-* Narrows an `OperationNode` to an `HttpOperationNode`, guaranteeing `method` and `path`.
-*
-* @example
-* ```ts
-* if (isHttpOperationNode(node)) {
-*   console.log(node.method, node.path)
-* }
-* ```
-*/
-function isHttpOperationNode(node) {
-	return node.protocol === "http" || node.method !== void 0 && node.path !== void 0;
-}
-//#endregion
-//#region src/utils/ast.ts
-const plainStringTypes = new Set([
-	"string",
-	"uuid",
-	"email",
-	"url",
-	"datetime"
-]);
-/**
-* Merges a ref node with its resolved schema, giving usage-site fields precedence.
-*
-* Usage-site fields (`description`, `readOnly`, `nullable`, `deprecated`) on the ref node
-* override the same fields in the resolved `node.schema`. Non-ref nodes are returned unchanged.
-*
-* @example
-* ```ts
-* // Ref with description override
-* 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
-	});
-}
-/**
-* Type guard that 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;
-}
-/**
-* Applies casing rules to parameter names and returns a new parameter array.
-*
-* Use this before passing parameters to schema builders so output property keys match
-* the desired casing while preserving `OperationNode.parameters` for other consumers.
-* The input array is not mutated. When `casing` is not set, the original array is returned unchanged.
-*/
-const caseParamsMemo = memoize(/* @__PURE__ */ new WeakMap(), (params) => memoize(/* @__PURE__ */ new Map(), (casing) => params.map((param) => {
-	const transformed = casing === "camelcase" || !require_utils.isValidVarName(param.name) ? require_utils.camelCase(param.name) : param.name;
-	return {
-		...param,
-		name: transformed
-	};
-})));
-function caseParams(params, casing) {
-	if (!casing) return params;
-	return caseParamsMemo(params)(casing);
-}
-/**
-* 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 createSchema({
-		type: "object",
-		primitive: "object",
-		properties: [createProperty({
-			name: propertyName,
-			schema: createSchema({
-				type: "enum",
-				primitive: "string",
-				enumValues: [value]
-			}),
-			required: true
-		})]
-	});
-}
-/**
-* Resolves the {@link TypeExpression} for an individual parameter.
-*
-* Without a resolver, falls back to the schema primitive (a plain type-name string).
-* When the parameter belongs to a named group, emits an {@link IndexedAccessTypeNode}
-* (`GroupParams['petId']`); otherwise the resolved individual name as a plain string.
-*/
-function resolveParamType({ node, param, resolver }) {
-	if (!resolver) return param.schema.primitive ?? "unknown";
-	const individualName = resolver.resolveParamName(node, param);
-	const groupLocation = param.in === "path" || param.in === "query" || param.in === "header" ? param.in : void 0;
-	const groupResolvers = {
-		path: resolver.resolvePathParamsName,
-		query: resolver.resolveQueryParamsName,
-		header: resolver.resolveHeaderParamsName
-	};
-	const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : void 0;
-	if (groupName && groupName !== individualName) return createIndexedAccessType({
-		objectType: groupName,
-		indexType: param.name
-	});
-	return individualName;
-}
-/**
-* Converts an `OperationNode` into function parameters for code generation.
-*
-* Centralizes parameter grouping logic for all plugins. `paramsType` chooses between one
-* destructured object parameter (`object`) and separate top-level parameters (`inline`), while
-* `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
-* name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
-*/
-function createOperationParams(node, options) {
-	const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
-	const dataName = paramNames?.data ?? "data";
-	const paramsName = paramNames?.params ?? "params";
-	const headersName = paramNames?.headers ?? "headers";
-	const pathName = paramNames?.path ?? "pathParams";
-	const wrapType = (type) => typeWrapper ? typeWrapper(type) : type;
-	const wrapTypeExpression = (type) => typeof type === "string" ? wrapType(type) : type;
-	const casedParams = caseParams(node.parameters, paramsCasing);
-	const pathParams = casedParams.filter((p) => p.in === "path");
-	const queryParams = casedParams.filter((p) => p.in === "query");
-	const headerParams = casedParams.filter((p) => p.in === "header");
-	const toProperty = (param) => ({
-		name: param.name,
-		type: wrapTypeExpression(resolveParamType({
-			node,
-			param,
-			resolver
-		})),
-		optional: !param.required
-	});
-	const emptyObjectDefault = (props) => props.every((p) => p.optional) ? "{}" : void 0;
-	const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.resolveDataName(node) ?? "unknown") : void 0;
-	const bodyProperty = bodyType ? [{
-		name: dataName,
-		type: bodyType,
-		optional: !(node.requestBody?.required ?? false)
-	}] : [];
-	const trailingGroups = [{
-		name: paramsName,
-		node,
-		params: queryParams,
-		groupType: resolveGroupType({
-			node,
-			params: queryParams,
-			group: "query",
-			resolver
-		}),
-		resolver,
-		wrapType
-	}, {
-		name: headersName,
-		node,
-		params: headerParams,
-		groupType: resolveGroupType({
-			node,
-			params: headerParams,
-			group: "header",
-			resolver
-		}),
-		resolver,
-		wrapType
-	}];
-	const params = [];
-	if (paramsType === "object") {
-		const children = [
-			...pathParams.map(toProperty),
-			...bodyProperty,
-			...trailingGroups.flatMap(buildGroupProperty)
-		];
-		if (children.length) params.push(createFunctionParameter({
-			properties: children,
-			default: emptyObjectDefault(children)
-		}));
-	} else {
-		if (pathParamsType === "inlineSpread" && pathParams.length) {
-			const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]);
-			params.push(createFunctionParameter({
-				name: pathName,
-				type: spreadType ? wrapType(spreadType) : void 0,
-				rest: true
-			}));
-		} else if (pathParamsType === "inline") params.push(...pathParams.map((p) => createFunctionParameter(toProperty(p))));
-		else if (pathParams.length) {
-			const pathChildren = pathParams.map(toProperty);
-			params.push(createFunctionParameter({
-				properties: pathChildren,
-				default: pathParamsDefault ?? emptyObjectDefault(pathChildren)
-			}));
-		}
-		params.push(...bodyProperty.map((p) => createFunctionParameter(p)));
-		params.push(...trailingGroups.flatMap(buildGroupParam));
-	}
-	params.push(...extraParams);
-	return createFunctionParameters({ params });
-}
-/**
-* Builds the property descriptor for a query or header group.
-* Returns an empty array when there are no params to emit.
-*
-* A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline
-* {@link TypeLiteralNode} from the individual params.
-*/
-function buildGroupProperty({ name, node, params, groupType, resolver, wrapType }) {
-	if (groupType) return [{
-		name,
-		type: typeof groupType.type === "string" ? wrapType(groupType.type) : groupType.type,
-		optional: groupType.optional
-	}];
-	if (params.length) return [{
-		name,
-		type: buildTypeLiteral({
-			node,
-			params,
-			resolver
-		}),
-		optional: params.every((p) => !p.required)
-	}];
-	return [];
-}
-/**
-* Builds a single {@link FunctionParameterNode} for a query or header group.
-* Returns an empty array when there are no params to emit.
-*
-* A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline
-* {@link TypeLiteralNode} from the individual params.
-*/
-function buildGroupParam(args) {
-	return buildGroupProperty(args).map((p) => createFunctionParameter(p));
-}
-/**
-* Derives a {@link ParamGroupType} for a query or header group from the resolver.
-*
-* Returns `null` when there is no resolver, no params, or the group name equals the
-* individual param name (so there is no real group to emit).
-*/
-function resolveGroupType({ node, params, group, resolver }) {
-	if (!resolver || !params.length) return null;
-	const firstParam = params[0];
-	const groupName = (group === "query" ? resolver.resolveQueryParamsName : resolver.resolveHeaderParamsName).call(resolver, node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
-	return {
-		type: groupName,
-		optional: params.every((p) => !p.required)
-	};
-}
-/**
-* Builds a {@link TypeLiteralNode} for an inline anonymous type grouping named fields.
-*
-* Used when query or header parameters have no dedicated group type name.
-* Each language printer renders this appropriately (TypeScript: `{ petId: string; name?: string }`).
-*/
-function buildTypeLiteral({ node, params, resolver }) {
-	return createTypeLiteral({ members: params.map((p) => ({
-		name: p.name,
-		type: resolveParamType({
-			node,
-			param: p,
-			resolver
-		}),
-		optional: !p.required
-	})) });
-}
-function sourceKey(source) {
-	return `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
-}
-function pathTypeKey(path, isTypeOnly) {
-	return `${path}:${isTypeOnly ?? false}`;
-}
-function exportKey(path, name, isTypeOnly, asAlias) {
-	return `${path}:${name ?? ""}:${isTypeOnly ?? false}:${asAlias ?? ""}`;
-}
-function importKey(path, name, isTypeOnly) {
-	return `${path}:${name ?? ""}:${isTypeOnly ?? false}`;
-}
-/**
-* Computes a multi-level sort key for exports and imports:
-* non-array names first (wildcards/namespace aliases). Type-only before value. Alphabetical path. Unnamed before named.
-*/
-function sortKey(node) {
-	const isArray = Array.isArray(node.name) ? "1" : "0";
-	const typeOnly = node.isTypeOnly ? "0" : "1";
-	const hasName = node.name != null ? "1" : "0";
-	const name = Array.isArray(node.name) ? node.name.toSorted().join("\0") : node.name ?? "";
-	return `${isArray}:${typeOnly}:${node.path}:${hasName}:${name}`;
-}
-/**
-* Deduplicates and merges `SourceNode` objects by `name + isExportable + isTypeOnly`.
-*
-* Unnamed sources are deduplicated by object reference. Returns a deduplicated array in original order.
-*/
-function combineSources(sources) {
-	const seen = /* @__PURE__ */ new Map();
-	for (const source of sources) {
-		const key = sourceKey(source);
-		if (!seen.has(key)) seen.set(key, source);
-	}
-	return [...seen.values()];
-}
-/**
-* Merges `incoming` names into `existing`, preserving order and dropping duplicates.
-*
-* Shared by `combineExports` and `combineImports` for the same-path name-merge case.
-*/
-function mergeNameArrays(existing, incoming) {
-	const merged = new Set(existing);
-	for (const name of incoming) merged.add(name);
-	return [...merged];
-}
-/**
-* Deduplicates and merges `ExportNode` objects by path and type.
-*
-* Named exports with the same path and `isTypeOnly` flag have their names merged into a single export.
-* Non-array exports are deduplicated by exact identity. Returns a sorted, deduplicated array.
-*/
-function combineExports(exports) {
-	const result = [];
-	const namedByPath = /* @__PURE__ */ new Map();
-	const seen = /* @__PURE__ */ new Set();
-	const keyed = exports.map((node) => ({
-		node,
-		key: sortKey(node)
-	}));
-	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
-	for (const { node: curr } of keyed) {
-		const { name, path, isTypeOnly, asAlias } = curr;
-		if (Array.isArray(name)) {
-			if (!name.length) continue;
-			const key = pathTypeKey(path, isTypeOnly);
-			const existing = namedByPath.get(key);
-			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
-			else {
-				const newItem = {
-					...curr,
-					name: [...new Set(name)]
-				};
-				result.push(newItem);
-				namedByPath.set(key, newItem);
-			}
-		} else {
-			const key = exportKey(path, name, isTypeOnly, asAlias);
-			if (!seen.has(key)) {
-				result.push(curr);
-				seen.add(key);
-			}
-		}
-	}
-	return result;
-}
-/**
-* Deduplicates and merges `ImportNode` objects, filtering out unused imports.
-*
-* Retains imports that are referenced in `source` or re-exported. Imports with the same path and
-* `isTypeOnly` flag have their names merged. Returns a sorted, deduplicated, filtered array.
-*
-* @note Use this when combining imports from multiple files to avoid duplicate declarations.
-*/
-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 importNameMemo = /* @__PURE__ */ new Map();
-	const canonicalizeName = (n) => {
-		if (typeof n === "string") return n;
-		const key = `${n.propertyName}:${n.name ?? ""}`;
-		if (!importNameMemo.has(key)) importNameMemo.set(key, n);
-		return importNameMemo.get(key);
-	};
-	const pathsWithUsedNamedImport = /* @__PURE__ */ new Set();
-	for (const node of imports) {
-		if (!Array.isArray(node.name)) continue;
-		if (node.name.some((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName))) pathsWithUsedNamedImport.add(node.path);
-	}
-	const result = [];
-	const namedByPath = /* @__PURE__ */ new Map();
-	const seen = /* @__PURE__ */ new Set();
-	const keyed = imports.map((node) => ({
-		node,
-		key: sortKey(node)
-	}));
-	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
-	for (const { node: curr } of keyed) {
-		if (curr.path === curr.root) continue;
-		const { path, isTypeOnly } = curr;
-		let { name } = curr;
-		if (Array.isArray(name)) {
-			name = [...new Set(name.map(canonicalizeName))].filter((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName));
-			if (!name.length) continue;
-			const key = pathTypeKey(path, isTypeOnly);
-			const existing = namedByPath.get(key);
-			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
-			else {
-				const newItem = {
-					...curr,
-					name
-				};
-				result.push(newItem);
-				namedByPath.set(key, newItem);
-			}
-		} else {
-			if (name && !isUsed(name) && !pathsWithUsedNamedImport.has(path)) continue;
-			const key = importKey(path, name, isTypeOnly);
-			if (!seen.has(key)) {
-				result.push(curr);
-				seen.add(key);
-			}
-		}
-	}
-	return result;
-}
-/**
-* Extracts all string content from a `CodeNode` tree recursively.
-*
-* Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
-* and nested node content. Used internally to build the full source string for import filtering.
-*/
-function extractStringsFromNodes(nodes) {
-	if (!nodes?.length) return "";
-	return nodes.map((node) => {
-		if (typeof node === "string") return node;
-		if (node.kind === "Text") return node.value;
-		if (node.kind === "Break") return "";
-		if (node.kind === "Jsx") return node.value;
-		const parts = [];
-		if ("params" in node && node.params) parts.push(node.params);
-		if ("generics" in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(", ") : node.generics);
-		if ("returnType" in node && node.returnType) parts.push(node.returnType);
-		if ("type" in node && typeof node.type === "string") parts.push(node.type);
-		const nested = extractStringsFromNodes(node.nodes);
-		if (nested) parts.push(nested);
-		return parts.join("\n");
-	}).filter(Boolean).join("\n");
-}
-/**
-* Resolves the schema name of a ref node, falling back through `ref` → `name` → nested `schema.name`.
-*
-* Returns `null` for non-ref nodes or when no name can be resolved. Use this to get a schema's
-* identifier for type definitions or error messages.
-*
-* @example
-* ```ts
-* resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' })
-* // => 'Pet'
-* ```
-*/
-function resolveRefName(node) {
-	if (!node || node.type !== "ref") return null;
-	if (node.ref) return require_utils.extractRefName(node.ref) ?? node.name ?? node.schema?.name ?? null;
-	return node.name ?? node.schema?.name ?? null;
-}
-/**
-* Collects every named schema referenced (transitively) from a node via ref edges.
-*
-* Refs are followed by name only, the resolved `node.schema` is not traversed inline.
-* Use this to determine schema dependencies, build reference graphs, or detect what schemas need to be emitted.
-*
-* @example Collect refs from a single schema
-* ```ts
-* const names = collectReferencedSchemaNames(petSchema)
-* // → Set { 'Category', 'Tag' }
-* ```
-*
-* @example Accumulate refs from multiple schemas into one set
-* ```ts
-* const out = new Set<string>()
-* for (const schema of schemas) {
-*   collectReferencedSchemaNames(schema, out)
-* }
-* ```
-*/
-const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
-	const refs = /* @__PURE__ */ new Set();
-	collect(node, { schema(child) {
-		if (child.type === "ref") {
-			const name = resolveRefName(child);
-			if (name) refs.add(name);
-		}
-	} });
-	return refs;
-});
-function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
-	if (!node) return out;
-	for (const name of collectSchemaRefs(node)) out.add(name);
-	return out;
-}
-/**
-* Collects the names of all top-level schemas transitively used by a set of operations.
-*
-* An operation uses a schema when any of its parameters, request body content, or responses
-* reference it, directly or indirectly through other named schemas.
-* The walk is iterative and safe against reference cycles.
-*
-* Use this together with `include` filters to determine which schemas from `components/schemas`
-* are reachable from the allowed operations, so that schemas used only by excluded operations
-* are not generated.
-*
-* @example Only generate schemas referenced by included operations
-* ```ts
-* const includedOps = operations.filter(op => resolver.resolveOptions(op, { options, include }) !== null)
-* const allowed = collectUsedSchemaNames(includedOps, schemas)
-*
-* for (const schema of schemas) {
-*   if (schema.name && !allowed.has(schema.name)) continue
-*   // … generate schema
-* }
-* ```
-*
-* @example Check whether a specific schema is needed
-* ```ts
-* const allowed = collectUsedSchemaNames(includedOps, schemas)
-* allowed.has('OrderStatus') // false when no included operation references OrderStatus
-* ```
-*/
-const collectUsedSchemaNamesMemo = memoize(/* @__PURE__ */ new WeakMap(), (ops) => memoize(/* @__PURE__ */ new WeakMap(), (schemas) => computeUsedSchemaNames(ops, schemas)));
-function computeUsedSchemaNames(operations, schemas) {
-	const schemaMap = /* @__PURE__ */ new Map();
-	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
-	const result = /* @__PURE__ */ new Set();
-	function visitSchema(schema) {
-		const directRefs = collectReferencedSchemaNames(schema);
-		for (const name of directRefs) if (!result.has(name)) {
-			result.add(name);
-			const namedSchema = schemaMap.get(name);
-			if (namedSchema) visitSchema(namedSchema);
-		}
-	}
-	for (const op of operations) for (const schema of collectLazy(op, {
-		depth: "shallow",
-		schema: (node) => node
-	})) visitSchema(schema);
-	return result;
-}
-function collectUsedSchemaNames(operations, schemas) {
-	return collectUsedSchemaNamesMemo(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));
-	}
-	const circular = /* @__PURE__ */ new Set();
-	for (const start of graph.keys()) {
-		const visited = /* @__PURE__ */ new Set();
-		const stack = [...graph.get(start) ?? []];
-		while (stack.length > 0) {
-			const node = stack.pop();
-			if (node === start) {
-				circular.add(start);
-				break;
-			}
-			if (visited.has(node)) continue;
-			visited.add(node);
-			const next = graph.get(node);
-			if (next) for (const r of next) stack.push(r);
-		}
-	}
-	return circular;
-});
-/**
-* Identifies all schemas that participate in circular dependency chains, including direct self-loops.
-*
-* Returns a Set of schema names with circular dependencies. Use this to wrap recursive schema positions
-* in deferred constructs (lazy getter, `z.lazy(() => …)`) to prevent infinite recursion when generated code runs.
-* Refs are followed by name only, keeping the algorithm linear in the schema graph size.
-*
-* @note Call this once on the full schema graph, then use `containsCircularRef()` to check individual schemas.
-*/
-function findCircularSchemas(schemas) {
-	if (schemas.length === 0) return EMPTY_CIRCULAR_SET;
-	return findCircularSchemasMemo(schemas);
-}
-/**
-* Type guard returning `true` when a schema or anything nested within it contains a ref to a circular schema.
-*
-* Use `excludeName` to ignore refs to specific schemas (useful when self-references are handled separately).
-* Commonly used with `findCircularSchemas()` to detect where lazy wrappers are needed in code generation.
-*
-* @note Returns `true` for the first matching circular ref found. Use for fast dependency checks.
-*/
-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/factory.ts
-/**
-* Identity-preserving node update: returns `node` unchanged when every field in
-* `changes` already equals (by reference) the current value, otherwise a new node
-* with the changes applied.
-*
-* Mirrors the TypeScript compiler's `factory.updateX` contract, pair it with the
-* structural sharing in {@link transform} so a no-op rewrite doesn't allocate and
-* downstream passes can detect "nothing changed" by identity. Comparison is
-* shallow: a structurally-equal but newly-allocated array/object counts as a change.
-*
-* @example
-* ```ts
-* update(node, { name: node.name })        // -> same `node` reference
-* update(node, { name: 'renamed' })        // -> new node, `name` replaced
-* ```
-*/
-function update(node, changes) {
-	for (const key in changes) if (changes[key] !== node[key]) return {
-		...node,
-		...changes
-	};
-	return node;
-}
-/**
-* Creates a fully resolved `FileNode` from a file input descriptor.
-*
-* Computes:
-* - `id` SHA256 hash of the file path
-* - `name` `baseName` without extension
-* - `extname` extension extracted from `baseName`
-*
-* Deduplicates:
-* - `sources` via `combineSources`
-* - `exports` via `combineExports`
-* - `imports` via `combineImports` (also filters unused imports)
-*
-* @throws {Error} when `baseName` has no extension.
-*
-* @example
-* ```ts
-* const file = createFile({
-*   baseName: 'petStore.ts',
-*   path: 'src/models/petStore.ts',
-*   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
-*   imports: [createImport({ name: ['z'], path: 'zod' })],
-*   exports: [createExport({ name: ['Pet'], path: './petStore' })],
-* })
-* // file.id      = SHA256 hash of 'src/models/petStore.ts'
-* // file.name    = 'petStore'
-* // file.extname = '.ts'
-* ```
-*/
-function createFile(input) {
-	const extname = node_path.default.extname(input.baseName) || (input.baseName.startsWith(".") ? input.baseName : "");
-	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
-	const source = (input.sources ?? []).flatMap((item) => item.nodes ?? []).map((node) => extractStringsFromNodes([node])).filter(Boolean).join("\n\n");
-	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
-	const combinedImports = input.imports?.length ? combineImports(input.imports, resolvedExports, source || void 0) : [];
-	const localNames = new Set((input.sources ?? []).map((item) => item.name).filter((name) => Boolean(name)));
-	const nameOf = (item) => typeof item === "string" ? item : item.name ?? item.propertyName;
-	const resolvedImports = combinedImports.filter((imp) => imp.path !== input.path).flatMap((imp) => {
-		if (!Array.isArray(imp.name)) return typeof imp.name === "string" && localNames.has(imp.name) ? [] : [imp];
-		const kept = imp.name.filter((item) => !localNames.has(nameOf(item)));
-		if (!kept.length) return [];
-		return [kept.length === imp.name.length ? imp : {
-			...imp,
-			name: kept
-		}];
-	});
-	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
-	return {
-		kind: "File",
-		...input,
-		id: (0, node_crypto.hash)("sha256", input.path, "hex"),
-		name: trimExtName(input.baseName),
-		extname,
-		imports: resolvedImports,
-		exports: resolvedExports,
-		sources: resolvedSources,
-		meta: input.meta ?? {}
-	};
-}
-//#endregion
 //#region src/printer.ts
 /**
 * Defines a schema printer: a function that takes a `SchemaNode` and emits
@@ -2083,11 +450,11 @@ function definePrinter(build) {
 }
 /**
 * Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
-**
+*
 * @example
 * ```ts
-* export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
-*   (node) => kindToHandlerKey[node.kind],
+* export const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionParamKind, Partial<Record<FunctionParamKind, FunctionParamNode>>>(
+*   (node) => node.kind,
 * )
 * ```
 */
@@ -2132,16 +499,16 @@ function createPrinterFactory(getKey) {
 * ```
 */
 function setDiscriminatorEnum({ node, propertyName, values, enumName }) {
-	const objectNode = narrowSchema(node, "object");
+	const objectNode = require_utils.narrowSchema(node, "object");
 	if (!objectNode?.properties?.length) return node;
 	if (!objectNode.properties.some((prop) => prop.name === propertyName)) return node;
-	return createSchema({
+	return require_utils.createSchema({
 		...objectNode,
 		properties: objectNode.properties.map((prop) => {
 			if (prop.name !== propertyName) return prop;
-			return createProperty({
+			return require_utils.createProperty({
 				...prop,
-				schema: createSchema({
+				schema: require_utils.createSchema({
 					type: "enum",
 					primitive: "string",
 					enumValues: values,
@@ -2167,11 +534,11 @@ function setDiscriminatorEnum({ node, propertyName, values, enumName }) {
 function* mergeAdjacentObjectsLazy(members) {
 	let acc;
 	for (const member of members) {
-		const objectMember = narrowSchema(member, "object");
+		const objectMember = require_utils.narrowSchema(member, "object");
 		if (objectMember && !objectMember.name && acc !== void 0) {
-			const accObject = narrowSchema(acc, "object");
+			const accObject = require_utils.narrowSchema(acc, "object");
 			if (accObject && !accObject.name) {
-				acc = createSchema({
+				acc = require_utils.createSchema({
 					...accObject,
 					properties: [...accObject.properties ?? [], ...objectMember.properties ?? []]
 				});
@@ -2199,7 +566,7 @@ function simplifyUnion(members) {
 	const scalarPrimitives = new Set(members.filter((member) => require_utils.isScalarPrimitive(member.type)).map((m) => m.type));
 	if (!scalarPrimitives.size) return members;
 	return members.filter((member) => {
-		const enumNode = narrowSchema(member, "enum");
+		const enumNode = require_utils.narrowSchema(member, "enum");
 		if (!enumNode) return true;
 		const primitive = enumNode.primitive;
 		if (!primitive) return true;
@@ -2210,7 +577,7 @@ function simplifyUnion(members) {
 	});
 }
 function setEnumName(propNode, parentName, propName, enumSuffix) {
-	const enumNode = narrowSchema(propNode, "enum");
+	const enumNode = require_utils.narrowSchema(propNode, "enum");
 	if (enumNode?.primitive === "boolean") return {
 		...propNode,
 		name: null
@@ -2223,82 +590,55 @@ function setEnumName(propNode, parentName, propName, enumSuffix) {
 }
 //#endregion
 exports.applyDedupe = applyDedupe;
-exports.arrowFunctionDef = arrowFunctionDef;
-exports.breakDef = breakDef;
+exports.arrowFunctionDef = require_utils.arrowFunctionDef;
+exports.breakDef = require_utils.breakDef;
 exports.buildDedupePlan = buildDedupePlan;
-exports.caseParams = caseParams;
-exports.collect = collect;
-exports.collectUsedSchemaNames = collectUsedSchemaNames;
-exports.constDef = constDef;
-exports.containsCircularRef = containsCircularRef;
-exports.contentDef = contentDef;
-exports.createArrowFunction = createArrowFunction;
-exports.createBreak = createBreak;
-exports.createConst = createConst;
-exports.createDiscriminantNode = createDiscriminantNode;
-exports.createExport = createExport;
-exports.createFile = createFile;
-exports.createFunction = createFunction;
-exports.createFunctionParameter = createFunctionParameter;
-exports.createFunctionParameters = createFunctionParameters;
-exports.createImport = createImport;
-exports.createIndexedAccessType = createIndexedAccessType;
-exports.createInput = createInput;
-exports.createJsx = createJsx;
-exports.createObjectBindingPattern = createObjectBindingPattern;
-exports.createOperation = createOperation;
-exports.createOperationParams = createOperationParams;
-exports.createOutput = createOutput;
-exports.createParameter = createParameter;
+exports.collect = require_utils.collect;
+exports.constDef = require_utils.constDef;
+exports.contentDef = require_utils.contentDef;
 exports.createPrinterFactory = createPrinterFactory;
-exports.createProperty = createProperty;
-exports.createResponse = createResponse;
-exports.createSchema = createSchema;
-exports.createSource = createSource;
-exports.createStreamInput = createStreamInput;
-exports.createText = createText;
-exports.createType = createType;
-exports.createTypeLiteral = createTypeLiteral;
-exports.defineNode = defineNode;
+exports.defineNode = require_utils.defineNode;
 exports.definePrinter = definePrinter;
 exports.defineSchemaDialect = defineSchemaDialect;
-exports.exportDef = exportDef;
-exports.extractStringsFromNodes = extractStringsFromNodes;
-exports.fileDef = fileDef;
-exports.findCircularSchemas = findCircularSchemas;
-exports.functionDef = functionDef;
-exports.functionParameterDef = functionParameterDef;
-exports.functionParametersDef = functionParametersDef;
+exports.exportDef = require_utils.exportDef;
+exports.extractStringsFromNodes = require_utils.extractStringsFromNodes;
+Object.defineProperty(exports, "factory", {
+	enumerable: true,
+	get: function() {
+		return require_factory.factory_exports;
+	}
+});
+exports.fileDef = require_utils.fileDef;
+exports.functionDef = require_utils.functionDef;
+exports.functionParameterDef = require_utils.functionParameterDef;
+exports.functionParametersDef = require_utils.functionParametersDef;
 exports.httpMethods = require_utils.httpMethods;
-exports.importDef = importDef;
-exports.indexedAccessTypeDef = indexedAccessTypeDef;
-exports.inputDef = inputDef;
-exports.isHttpOperationNode = isHttpOperationNode;
-exports.isStringType = isStringType;
-exports.jsxDef = jsxDef;
+exports.importDef = require_utils.importDef;
+exports.indexedAccessTypeDef = require_utils.indexedAccessTypeDef;
+exports.inputDef = require_utils.inputDef;
+exports.isHttpOperationNode = require_utils.isHttpOperationNode;
+exports.jsxDef = require_utils.jsxDef;
 exports.mergeAdjacentObjectsLazy = mergeAdjacentObjectsLazy;
-exports.narrowSchema = narrowSchema;
-exports.objectBindingPatternDef = objectBindingPatternDef;
-exports.operationDef = operationDef;
-exports.outputDef = outputDef;
-exports.parameterDef = parameterDef;
-exports.propertyDef = propertyDef;
-exports.requestBodyDef = requestBodyDef;
-exports.responseDef = responseDef;
-exports.schemaDef = schemaDef;
+exports.narrowSchema = require_utils.narrowSchema;
+exports.objectBindingPatternDef = require_utils.objectBindingPatternDef;
+exports.operationDef = require_utils.operationDef;
+exports.outputDef = require_utils.outputDef;
+exports.parameterDef = require_utils.parameterDef;
+exports.propertyDef = require_utils.propertyDef;
+exports.requestBodyDef = require_utils.requestBodyDef;
+exports.responseDef = require_utils.responseDef;
+exports.schemaDef = require_utils.schemaDef;
 exports.schemaTypes = require_utils.schemaTypes;
 exports.setDiscriminatorEnum = setDiscriminatorEnum;
 exports.setEnumName = setEnumName;
 exports.signatureOf = signatureOf;
 exports.simplifyUnion = simplifyUnion;
-exports.sourceDef = sourceDef;
-exports.syncOptionality = syncOptionality;
-exports.syncSchemaRef = syncSchemaRef;
-exports.textDef = textDef;
-exports.transform = transform;
-exports.typeDef = typeDef;
-exports.typeLiteralDef = typeLiteralDef;
-exports.update = update;
-exports.walk = walk;
+exports.sourceDef = require_utils.sourceDef;
+exports.syncOptionality = require_utils.syncOptionality;
+exports.textDef = require_utils.textDef;
+exports.transform = require_utils.transform;
+exports.typeDef = require_utils.typeDef;
+exports.typeLiteralDef = require_utils.typeLiteralDef;
+exports.walk = require_utils.walk;
 
 //# sourceMappingURL=index.cjs.map