@kubb/ast 5.0.0-beta.62 → 5.0.0-beta.64

package/dist/{utils-DW9rnfsD.js → utils-BJi0y-xg.js}

@@ -1,6 +1,6 @@
-import "./chunk-CNktS9qV.js";
-import { d as resolveRefName, h as INDENT, m as narrowSchema, n as collectLazy, t as collect, u as resolveGroupType } from "./visitor-DepQEKyp.js";
-import { Q as createSchema, X as camelCase, _ as createIndexedAccessType, g as createFunctionParameters, h as createFunctionParameter, y as createTypeLiteral } from "./response-Rd1uisM1.js";
+import "./rolldown-runtime-CNktS9qV.js";
+import { a as resolveGroupType, c as collect, h as INDENT, l as collectLazy, m as narrowSchema, o as resolveRefName } from "./refs-Dx6U5LoE.js";
+import { L as camelCase, S as createTypeLiteral, b as createIndexedAccessType, t as createSchema, v as createFunctionParameter, y as createFunctionParameters } from "./schema-YNbOtTCM.js";
 //#region ../../internals/utils/src/promise.ts
 /**
 * Wraps `factory` with a keyed cache backed by the provided store.
@@ -178,8 +178,8 @@ function singleQuote(value) {
 //#endregion
 //#region src/utils/codegen.ts
 /**
-* Builds a JSDoc comment block from an array of lines, returning `fallback` when there are no
-* comments so callers always get a usable string.
+* Builds a JSDoc comment block from an array of lines. Returns `fallback` when there are no
+* comments.
 *
 * @example
 * ```ts
@@ -214,9 +214,8 @@ function objectKey(name) {
 }
 /**
 * Assembles a multi-line object literal from already-rendered `entries`, indenting each entry one
-* level and closing the brace at column zero. Nested objects built the same way indent cumulatively,
-* so callers never re-parse the generated code. A trailing comma is added per entry to match the
-* formatter's multi-line style.
+* level and closing the brace at column zero. Entries that are themselves multi-line objects indent
+* cumulatively. Each entry ends with a trailing comma to match the formatter's multi-line style.
 *
 * @example
 * ```ts
@@ -231,8 +230,8 @@ function buildObject(entries) {
 /**
 * Assembles a bracketed list (array by default) from already-rendered `items`. Keeps everything on
 * one line when no item spans multiple lines, and otherwise puts each item on its own line, indented
-* one level with a trailing comma and the closing bracket at column zero. Use it for `z.union([…])`,
-* `z.array([…])`, and similar member lists so objects inside them nest correctly.
+* one level with a trailing comma and the closing bracket at column zero. Used for member lists such
+* as `z.union([…])` and `z.array([…])`.
 *
 * @example
 * ```ts
@@ -250,8 +249,8 @@ function buildList(items, brackets = ["[", "]"]) {
 //#region src/utils/schemaMerge.ts
 /**
 * Merges a run of adjacent anonymous object members into one. Named or non-object members break the
-* run and pass through. Stays a construction-time helper, not a macro, so callers keep control of the
-* member boundaries (such as keeping synthetic discriminant objects out of a run).
+* run and pass through unchanged. The merge follows member order, so callers control which members
+* combine by where they place them in the sequence.
 *
 * @example
 * ```ts
@@ -394,14 +393,28 @@ function getNestedAccessor(param, accessor) {
 //#endregion
 //#region src/utils/schemaGraph.ts
 /**
-* Collects every named schema referenced transitively from a node through its ref edges.
+* Memoized inner pass that walks a single node and returns the names of every schema it references.
+*/
+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;
+});
+/**
+* Collects the names of every ref found anywhere inside a node's own subtree.
 *
-* Refs are followed by name only, so the resolved `node.schema` is never traversed inline.
+* Each ref contributes its name only, so the schema it points to is never traversed here. Pass `out`
+* to accumulate names from several nodes into one set.
 *
 * @example Collect refs from a single schema
 * ```ts
 * const names = collectReferencedSchemaNames(petSchema)
-* // → Set { 'Category', 'Tag' }
+* // Set { 'Category', 'Tag' }
 * ```
 *
 * @example Accumulate refs from multiple schemas into one set
@@ -412,39 +425,13 @@ function getNestedAccessor(param, accessor) {
 * }
 * ```
 */
-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 its parameters, request body, or responses reference it, directly
-* or through other named schemas. The walk is iterative, so reference cycles are safe.
-*
-* Pair it with `include` filters so schemas reachable only from excluded operations stay ungenerated.
-*
-* @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
-* }
-* ```
+* Memoized two-level cache keyed first on the operations array, then on the schemas array.
 */
 const collectUsedSchemaNamesMemo = memoize(/* @__PURE__ */ new WeakMap(), (ops) => memoize(/* @__PURE__ */ new WeakMap(), (schemas) => computeUsedSchemaNames(ops, schemas)));
 function computeUsedSchemaNames(operations, schemas) {
@@ -465,6 +452,26 @@ function computeUsedSchemaNames(operations, schemas) {
 	})) visitSchema(schema);
 	return result;
 }
+/**
+* Collects the names of all top-level schemas transitively used by a set of operations.
+*
+* An operation uses a schema when its parameters, request body, or responses reference it, directly
+* or through other named schemas. Once a name is added to the result it is not revisited, so
+* reference cycles terminate.
+*
+* Pair it with `include` filters so schemas reachable only from excluded operations stay ungenerated.
+*
+* @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
+* }
+* ```
+*/
 function collectUsedSchemaNames(operations, schemas) {
 	return collectUsedSchemaNamesMemo(operations)(schemas);
 }
@@ -578,13 +585,6 @@ function lazyGetter({ name, body }) {
 }
 //#endregion
 //#region src/utils/operationParams.ts
-/**
-* Applies casing rules to parameter names and returns a new array without mutating the input.
-*
-* Run it before handing parameters to schema builders so output property keys get the right casing
-* while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, 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" || !isValidVarName(param.name) ? camelCase(param.name) : param.name;
 	return {
@@ -592,6 +592,13 @@ const caseParamsMemo = memoize(/* @__PURE__ */ new WeakMap(), (params) => memoiz
 		name: transformed
 	};
 })));
+/**
+* Applies casing rules to parameter names and returns a new array without mutating the input.
+*
+* Run it before handing parameters to schema builders so output property keys get the right casing
+* while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, the
+* original array is returned unchanged.
+*/
 function caseParams(params, casing) {
 	if (!casing) return params;
 	return caseParamsMemo(params)(casing);
@@ -767,4 +774,4 @@ function buildTypeLiteral({ node, params, resolver }) {
 //#endregion
 export { objectKey as C, buildObject as S, toRegExpString as _, resolveParamType as a, buildJSDoc as b, mapSchemaMembers as c, containsCircularRef as d, findCircularSchemas as f, stringifyObject as g, stringify as h, createOperationParams as i, mapSchemaProperties as l, jsStringEscape as m, buildTypeLiteral as n, lazyGetter as o, getNestedAccessor as p, caseParams as r, mapSchemaItems as s, buildGroupParam as t, collectUsedSchemaNames as u, trimQuotes as v, isValidVarName as w, buildList as x, mergeAdjacentObjectsLazy as y };
 
-//# sourceMappingURL=utils-DW9rnfsD.js.map
+//# sourceMappingURL=utils-BJi0y-xg.js.map

package/dist/utils-BJi0y-xg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-BJi0y-xg.js","names":[],"sources":["../../../internals/utils/src/promise.ts","../../../internals/utils/src/reserved.ts","../../../internals/utils/src/string.ts","../src/utils/codegen.ts","../src/utils/schemaMerge.ts","../src/utils/strings.ts","../src/utils/schemaGraph.ts","../src/utils/schemaTraversal.ts","../src/utils/operationParams.ts"],"sourcesContent":["function* chunks<T>(arr: ReadonlyArray<T>, size: number): Generator<Array<T>> {\n  for (let i = 0; i < arr.length; i += size) {\n    yield arr.slice(i, i + size)\n  }\n}\n\nexport type ForBatchesOptions = {\n  /**\n   * Maximum batch size handed to `process`.\n   * Parallel dispatch within a batch is the caller's responsibility\n   * (typically via `Promise.all(batch.map(...))`).\n   */\n  concurrency: number\n  /**\n   * Called after every batch.\n   *\n   * Use a cheap, idempotent callback (e.g. one that short-circuits when there\n   * is nothing new to do). The helper does not coalesce calls — if you need\n   * throttling, do it inside `flush` itself.\n   */\n  flush?: () => Promise<void>\n}\n\n/**\n * Slices `source` into batches of `concurrency` items and awaits `process` for each batch.\n * Accepts both plain arrays (sync) and `AsyncIterable` (streaming).\n *\n * `process` controls whether items inside a batch run in parallel; this helper only\n * controls batch size and per-batch flushing.\n *\n * @example\n * ```ts\n * // parallel dispatch inside each batch\n * await forBatches(schemas, (batch) => Promise.all(batch.map(process)), { concurrency: 8 })\n *\n * // async iterable with a flush after every batch\n * await forBatches(stream.schemas, (batch) => dispatch(batch), { concurrency: 8, flush })\n * ```\n */\nexport async function forBatches<T>(\n  source: ReadonlyArray<T> | AsyncIterable<T>,\n  process: (batch: Array<T>) => Promise<unknown>,\n  options: ForBatchesOptions,\n): Promise<void> {\n  const { concurrency, flush } = options\n\n  if (Array.isArray(source)) {\n    for (const batch of chunks(source, concurrency)) {\n      await process(batch)\n      if (flush) await flush()\n    }\n    return\n  }\n\n  const batch: Array<T> = []\n  for await (const item of source) {\n    batch.push(item)\n    if (batch.length >= concurrency) {\n      await process(batch.splice(0))\n\n      if (flush) await flush()\n    }\n  }\n  if (batch.length > 0) {\n    await process(batch.splice(0))\n\n    if (flush) await flush()\n  }\n}\n\n/** A value that may already be resolved or still pending.\n *\n * @example\n * ```ts\n * function load(id: string): PossiblePromise<string> {\n *   return cache.get(id) ?? fetchRemote(id)\n * }\n * ```\n */\nexport type PossiblePromise<T> = Promise<T> | T\n\n/** Returns `true` when `result` is a thenable `Promise`.\n *\n * @example\n * ```ts\n * isPromise(Promise.resolve(1)) // true\n * isPromise(42)                 // false\n * ```\n */\nexport function isPromise<T>(result: PossiblePromise<T>): result is Promise<T> {\n  return result !== null && result !== undefined && typeof (result as Record<string, unknown>)['then'] === 'function'\n}\n\n/** Returns `true` when `result` is a rejected `Promise.allSettled` result with a typed `reason`.\n *\n * @example\n * ```ts\n * const results = await Promise.allSettled([p1, p2])\n * results.filter(isPromiseRejectedResult<Error>).map((r) => r.reason.message)\n * ```\n */\nexport function isPromiseRejectedResult<T>(result: PromiseSettledResult<unknown>): result is Omit<PromiseRejectedResult, 'reason'> & { reason: T } {\n  return result.status === 'rejected'\n}\n\ntype Store<TKey, TValue> = {\n  has(key: TKey): boolean\n  get(key: TKey): TValue | undefined\n  set(key: TKey, value: TValue): unknown\n}\n\n/**\n * Wraps `factory` with a keyed cache backed by the provided store.\n *\n * Pass a `WeakMap` for object keys (results are GC-eligible when the key is\n * collected) or a `Map` for primitive keys. For multi-argument functions,\n * nest two `memoize` calls — the outer keyed by the first argument, the\n * inner (created once per outer miss) keyed by the second.\n *\n * Because the cache is owned by the caller, it can be shared, inspected, or\n * cleared independently of the memoized function.\n *\n * @example Single WeakMap key\n * ```ts\n * const cache = new WeakMap<SchemaNode, Set<string>>()\n * const getRefs = memoize(cache, (node) => collectRefs(node))\n * ```\n *\n * @example Single Map key (primitive)\n * ```ts\n * const cache = new Map<string, Resolver>()\n * const getResolver = memoize(cache, (name) => buildResolver(name))\n * ```\n *\n * @example Two-level (object + primitive)\n * ```ts\n * const outer = new WeakMap<Params[], Map<string, Params[]>>()\n * const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))\n * fn(params)('camelcase')\n * ```\n */\nexport function memoize<TKey, TValue>(store: Store<TKey, TValue>, factory: (key: TKey) => TValue): (key: TKey) => TValue {\n  return (key: TKey): TValue => {\n    if (store.has(key)) return store.get(key)!\n    const value = factory(key)\n    store.set(key, value)\n    return value\n  }\n}\n\n/**\n * Container that switches between an eager `Array<T>` and a lazy `AsyncIterable<T>`.\n *\n * `Array<T>` by default. With `Stream` set to `true` it becomes `AsyncIterable<T>`, so large\n * collections can be produced lazily without holding every item in memory. Pairs with\n * {@link arrayToAsyncIterable}, which lifts a plain array into the streaming form.\n *\n * @example\n * ```ts\n * type Eager = Streamable<number> // Array<number>\n * type Lazy = Streamable<number, true> // AsyncIterable<number>\n * ```\n */\nexport type Streamable<T, Stream extends boolean = false> = Stream extends true ? AsyncIterable<T> : Array<T>\n\n/**\n * Wraps a plain array in a reusable `AsyncIterable`.\n * Each `[Symbol.asyncIterator]()` call returns a fresh generator so the\n * iterable can be consumed multiple times (e.g. once per plugin pre-scan).\n *\n * @example\n * ```ts\n * const stream = arrayToAsyncIterable([1, 2, 3])\n * for await (const n of stream) console.log(n) // 1, 2, 3\n * ```\n */\nexport function arrayToAsyncIterable<T>(arr: ReadonlyArray<T>): AsyncIterable<T> {\n  return {\n    [Symbol.asyncIterator]() {\n      return (async function* () {\n        yield* arr\n      })()\n    },\n  }\n}\n","/**\n * JavaScript and Java reserved words.\n * @link https://github.com/jonschlinkert/reserved/blob/master/index.js\n */\nconst reservedWords = new Set([\n  'abstract',\n  'arguments',\n  'boolean',\n  'break',\n  'byte',\n  'case',\n  'catch',\n  'char',\n  'class',\n  'const',\n  'continue',\n  'debugger',\n  'default',\n  'delete',\n  'do',\n  'double',\n  'else',\n  'enum',\n  'eval',\n  'export',\n  'extends',\n  'false',\n  'final',\n  'finally',\n  'float',\n  'for',\n  'function',\n  'goto',\n  'if',\n  'implements',\n  'import',\n  'in',\n  'instanceof',\n  'int',\n  'interface',\n  'let',\n  'long',\n  'native',\n  'new',\n  'null',\n  'package',\n  'private',\n  'protected',\n  'public',\n  'return',\n  'short',\n  'static',\n  'super',\n  'switch',\n  'synchronized',\n  'this',\n  'throw',\n  'throws',\n  'transient',\n  'true',\n  'try',\n  'typeof',\n  'var',\n  'void',\n  'volatile',\n  'while',\n  'with',\n  'yield',\n  'Array',\n  'Date',\n  'hasOwnProperty',\n  'Infinity',\n  'isFinite',\n  'isNaN',\n  'isPrototypeOf',\n  'length',\n  'Math',\n  'name',\n  'NaN',\n  'Number',\n  'Object',\n  'prototype',\n  'String',\n  'toString',\n  'undefined',\n  'valueOf',\n] as const)\n\n/**\n * Prefixes `word` with `_` when it is a reserved JavaScript/Java identifier or starts with a digit.\n *\n * @example\n * ```ts\n * transformReservedWord('class')  // '_class'\n * transformReservedWord('42foo')  // '_42foo'\n * transformReservedWord('status') // 'status'\n * ```\n */\nexport function transformReservedWord(word: string): string {\n  const firstChar = word.charCodeAt(0)\n  if (word && (reservedWords.has(word as 'valueOf') || (firstChar >= 48 && firstChar <= 57))) {\n    return `_${word}`\n  }\n  return word\n}\n\n/**\n * Returns `true` when `name` is a syntactically valid JavaScript variable name.\n *\n * @example\n * ```ts\n * isValidVarName('status')  // true\n * isValidVarName('class')   // false (reserved word)\n * isValidVarName('42foo')   // false (starts with digit)\n * ```\n */\nexport function isValidVarName(name: string): boolean {\n  if (!name || reservedWords.has(name as 'valueOf')) {\n    return false\n  }\n  return isIdentifier(name)\n}\n\n/**\n * Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.\n *\n * Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys\n * even though they are not valid variable names, so use this (not {@link isValidVarName}) when\n * deciding whether an object key needs quoting.\n *\n * @example\n * ```ts\n * isIdentifier('name')   // true\n * isIdentifier('x-total')// false\n * ```\n */\nexport function isIdentifier(name: string): boolean {\n  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)\n}\n","/**\n * Wraps a value in single quotes for emitting a single-quoted JavaScript string literal, escaping\n * any backslash or single quote in the content.\n *\n * @example\n * ```ts\n * singleQuote('foo')      // \"'foo'\"\n * singleQuote(\"o'clock\")  // \"'o\\\\'clock'\"\n * ```\n */\nexport function singleQuote(value: string | number | boolean | undefined | null): string {\n  if (value === undefined || value === null) return \"''\"\n  const escaped = String(value).replace(/\\\\/g, '\\\\\\\\').replace(/'/g, \"\\\\'\")\n\n  return `'${escaped}'`\n}\n","import { isIdentifier, singleQuote } from '@internals/utils'\nimport { INDENT } from '../constants.ts'\n\n/**\n * Builds a JSDoc comment block from an array of lines. Returns `fallback` when there are no\n * comments.\n *\n * @example\n * ```ts\n * buildJSDoc(['@type string', '@example hello'])\n * // '/**\\n   * @type string\\n   * @example hello\\n   *\\/\\n  '\n * ```\n */\nexport function buildJSDoc(\n  comments: Array<string>,\n  options: {\n    /**\n     * String used to indent each comment line.\n     * @default '   * '\n     */\n    indent?: string\n    /**\n     * String appended after the closing tag.\n     * @default '\\n  '\n     */\n    suffix?: string\n    /**\n     * Returned as-is when `comments` is empty.\n     * @default '  '\n     */\n    fallback?: string\n  } = {},\n): string {\n  const { indent = '   * ', suffix = '\\n  ', fallback = '  ' } = options\n\n  if (comments.length === 0) return fallback\n\n  return `/**\\n${comments.map((c) => `${indent}${c}`).join('\\n')}\\n   */${suffix}`\n}\n\n/**\n * Indents every non-empty line of `text` by one indent level, leaving blank lines empty.\n */\nfunction indentLines(text: string): string {\n  if (!text) return ''\n  return text\n    .split('\\n')\n    .map((line) => (line.trim() ? `${INDENT}${line}` : ''))\n    .join('\\n')\n}\n\n/**\n * Renders an object key, quoting it with single quotes only when it is not a valid identifier.\n * Reserved words and globals (`name`, `class`, …) are valid bare keys and stay unquoted.\n *\n * @example\n * ```ts\n * objectKey('name')    // 'name'\n * objectKey('x-total') // \"'x-total'\"\n * ```\n */\nexport function objectKey(name: string): string {\n  return isIdentifier(name) ? name : singleQuote(name)\n}\n\n/**\n * Assembles a multi-line object literal from already-rendered `entries`, indenting each entry one\n * level and closing the brace at column zero. Entries that are themselves multi-line objects indent\n * cumulatively. Each entry ends with a trailing comma to match the formatter's multi-line style.\n *\n * @example\n * ```ts\n * buildObject(['id: z.number()', 'name: z.string()'])\n * // '{\\n  id: z.number(),\\n  name: z.string(),\\n}'\n * ```\n */\nexport function buildObject(entries: Array<string>): string {\n  if (entries.length === 0) return '{}'\n  const body = entries.map((entry) => `${indentLines(entry)},`).join('\\n')\n\n  return `{\\n${body}\\n}`\n}\n\n/**\n * Assembles a bracketed list (array by default) from already-rendered `items`. Keeps everything on\n * one line when no item spans multiple lines, and otherwise puts each item on its own line, indented\n * one level with a trailing comma and the closing bracket at column zero. Used for member lists such\n * as `z.union([…])` and `z.array([…])`.\n *\n * @example\n * ```ts\n * buildList(['z.string()', 'z.number()'])\n * // '[z.string(), z.number()]'\n * ```\n */\nexport function buildList(items: Array<string>, brackets: [open: string, close: string] = ['[', ']']): string {\n  const [open, close] = brackets\n  if (items.length === 0) return `${open}${close}`\n  if (!items.some((item) => item.includes('\\n'))) return `${open}${items.join(', ')}${close}`\n  const body = items.map((item) => `${indentLines(item)},`).join('\\n')\n\n  return `${open}\\n${body}\\n${close}`\n}\n","import { narrowSchema } from '../guards.ts'\nimport { createSchema, type SchemaNode } from '../nodes/schema.ts'\n\n/**\n * Merges a run of adjacent anonymous object members into one. Named or non-object members break the\n * run and pass through unchanged. The merge follows member order, so callers control which members\n * combine by where they place them in the sequence.\n *\n * @example\n * ```ts\n * const merged = [...mergeAdjacentObjectsLazy([objectA, objectB])]\n * ```\n */\nexport function* mergeAdjacentObjectsLazy(members: Iterable<SchemaNode>): Generator<SchemaNode, void, undefined> {\n  let acc: SchemaNode | undefined\n\n  for (const member of members) {\n    const objectMember = narrowSchema(member, 'object')\n    if (objectMember && !objectMember.name && acc !== undefined) {\n      const accObject = narrowSchema(acc, 'object')\n      if (accObject && !accObject.name) {\n        acc = createSchema({\n          ...accObject,\n          properties: [...(accObject.properties ?? []), ...(objectMember.properties ?? [])],\n        })\n        continue\n      }\n    }\n    if (acc !== undefined) yield acc\n    acc = member\n  }\n\n  if (acc !== undefined) yield acc\n}\n","/**\n * Strips a single matching pair of `\"...\"`, `'...'`, or `` `...` `` from both ends of `text`.\n * Returns the string unchanged when no balanced quote pair is found.\n *\n * @example\n * ```ts\n * trimQuotes('\"hello\"') // 'hello'\n * trimQuotes('hello')   // 'hello'\n * ```\n */\nexport function trimQuotes(text: string): string {\n  if (text.length >= 2) {\n    const first = text[0]\n    const last = text[text.length - 1]\n    if ((first === '\"' && last === '\"') || (first === \"'\" && last === \"'\") || (first === '`' && last === '`')) {\n      return text.slice(1, -1)\n    }\n  }\n  return text\n}\n\n/**\n * Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.\n *\n * Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated\n * code matches the repo style without a formatter.\n *\n * @example\n * ```ts\n * stringify('hello')   // \"'hello'\"\n * stringify('\"hello\"') // \"'hello'\"\n * ```\n */\nexport function stringify(value: string | number | boolean | undefined): string {\n  if (value === undefined || value === null) return \"''\"\n  const json = JSON.stringify(trimQuotes(value.toString()))\n  const inner = json.slice(1, -1).replace(/\\\\\"/g, '\"').replace(/'/g, \"\\\\'\")\n  return `'${inner}'`\n}\n\n/**\n * Escapes characters that are not allowed inside JS string literals, covering quotes, backslashes,\n * and the Unicode line terminators U+2028 and U+2029.\n *\n * @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4\n *\n * @example\n * ```ts\n * jsStringEscape('say \"hi\"\\nbye') // 'say \\\\\"hi\\\\\"\\\\nbye'\n * ```\n */\nexport function jsStringEscape(input: unknown): string {\n  return `${input}`.replace(/[\"'\\\\\\n\\r\\u2028\\u2029]/g, (character) => {\n    switch (character) {\n      case '\"':\n      case \"'\":\n      case '\\\\':\n        return `\\\\${character}`\n      case '\\n':\n        return '\\\\n'\n      case '\\r':\n        return '\\\\r'\n      case '\\u2028':\n        return '\\\\u2028'\n      case '\\u2029':\n        return '\\\\u2029'\n      default:\n        return ''\n    }\n  })\n}\n\n/**\n * Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.\n * Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.\n * Pass `null` as the second argument to emit a `/pattern/flags` literal instead.\n *\n * @example\n * ```ts\n * toRegExpString('^(?im)foo')       // 'new RegExp(\"^foo\", \"im\")'\n * toRegExpString('^(?im)foo', null) // '/^foo/im'\n * ```\n */\nexport function toRegExpString(text: string, func: string | null = 'RegExp'): string {\n  const raw = trimQuotes(text)\n\n  const match = raw.match(/^\\^(\\(\\?([igmsuy]+)\\))/i)\n  const replacementTarget = match?.[1] ?? ''\n  const matchedFlags = match?.[2]\n  const cleaned = raw\n    .replace(/^\\\\?\\//, '')\n    .replace(/\\\\?\\/$/, '')\n    .replace(replacementTarget, '')\n\n  const { source, flags } = new RegExp(cleaned, matchedFlags)\n\n  if (func === null) return `/${source}/${flags}`\n\n  return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ''})`\n}\n\n/**\n * Renders a plain object as multi-line `key: value` source for embedding in generated code. Nested\n * objects recurse with fixed indentation, so the result drops straight into an object literal\n * without re-parsing.\n *\n * @example\n * ```ts\n * stringifyObject({ foo: 'bar', nested: { a: 1 } })\n * // 'foo: bar,\\nnested: {\\n        a: 1\\n      }'\n * ```\n */\nexport function stringifyObject(value: Record<string, unknown>): string {\n  const items = Object.entries(value)\n    .map(([key, val]) => {\n      if (val !== null && typeof val === 'object') {\n        return `${key}: {\\n        ${stringifyObject(val as Record<string, unknown>)}\\n      }`\n      }\n      return `${key}: ${val}`\n    })\n    .filter(Boolean)\n  return items.join(',\\n')\n}\n\n/**\n * Renders a dotted path or string array as an optional-chaining accessor expression rooted at\n * `accessor`. Returns `null` for an empty path.\n *\n * @example\n * ```ts\n * getNestedAccessor('pagination.next.id', 'lastPage')\n * // \"lastPage?.['pagination']?.['next']?.['id']\"\n * ```\n */\nexport function getNestedAccessor(param: string | Array<string>, accessor: string): string | null {\n  const parts = Array.isArray(param) ? param : param.split('.')\n  if (parts.length === 0 || (parts.length === 1 && parts[0] === '')) return null\n  return `${accessor}?.['${`${parts.join(\"']?.['\")}']`}`\n}\n","import { memoize } from '@internals/utils'\nimport type { OperationNode, SchemaNode } from '../nodes/index.ts'\nimport { collect, collectLazy } from '../visitor.ts'\nimport { resolveRefName } from './refs.ts'\n\n/**\n * Memoized inner pass that walks a single node and returns the names of every schema it references.\n */\nconst collectSchemaRefs = memoize(new WeakMap<SchemaNode, ReadonlySet<string>>(), (node: SchemaNode): ReadonlySet<string> => {\n  const refs = new Set<string>()\n  collect<void>(node, {\n    schema(child) {\n      if (child.type === 'ref') {\n        const name = resolveRefName(child)\n        if (name) refs.add(name)\n      }\n    },\n  })\n  return refs\n})\n\n/**\n * Collects the names of every ref found anywhere inside a node's own subtree.\n *\n * Each ref contributes its name only, so the schema it points to is never traversed here. Pass `out`\n * to accumulate names from several nodes into one set.\n *\n * @example Collect refs from a single schema\n * ```ts\n * const names = collectReferencedSchemaNames(petSchema)\n * // Set { 'Category', 'Tag' }\n * ```\n *\n * @example Accumulate refs from multiple schemas into one set\n * ```ts\n * const out = new Set<string>()\n * for (const schema of schemas) {\n *   collectReferencedSchemaNames(schema, out)\n * }\n * ```\n */\nexport function collectReferencedSchemaNames(node: SchemaNode | undefined, out: Set<string> = new Set()): Set<string> {\n  if (!node) return out\n  for (const name of collectSchemaRefs(node)) out.add(name)\n  return out\n}\n\n/**\n * Memoized two-level cache keyed first on the operations array, then on the schemas array.\n */\nconst collectUsedSchemaNamesMemo = memoize(new WeakMap<ReadonlyArray<OperationNode>, (schemas: ReadonlyArray<SchemaNode>) => Set<string>>(), (ops) =>\n  memoize(new WeakMap<ReadonlyArray<SchemaNode>, Set<string>>(), (schemas) => computeUsedSchemaNames(ops, schemas)),\n)\n\nfunction computeUsedSchemaNames(operations: ReadonlyArray<OperationNode>, schemas: ReadonlyArray<SchemaNode>): Set<string> {\n  const schemaMap = new Map<string, SchemaNode>()\n  for (const schema of schemas) {\n    if (schema.name) schemaMap.set(schema.name, schema)\n  }\n\n  const result = new Set<string>()\n\n  function visitSchema(schema: SchemaNode): void {\n    const directRefs = collectReferencedSchemaNames(schema)\n    for (const name of directRefs) {\n      if (!result.has(name)) {\n        result.add(name)\n        const namedSchema = schemaMap.get(name)\n        if (namedSchema) visitSchema(namedSchema)\n      }\n    }\n  }\n\n  for (const op of operations) {\n    for (const schema of collectLazy<SchemaNode>(op, { depth: 'shallow', schema: (node) => node })) {\n      visitSchema(schema)\n    }\n  }\n\n  return result\n}\n\n/**\n * Collects the names of all top-level schemas transitively used by a set of operations.\n *\n * An operation uses a schema when its parameters, request body, or responses reference it, directly\n * or through other named schemas. Once a name is added to the result it is not revisited, so\n * reference cycles terminate.\n *\n * Pair it with `include` filters so schemas reachable only from excluded operations stay ungenerated.\n *\n * @example Only generate schemas referenced by included operations\n * ```ts\n * const includedOps = operations.filter((op) => resolver.resolveOptions(op, { options, include }) !== null)\n * const allowed = collectUsedSchemaNames(includedOps, schemas)\n *\n * for (const schema of schemas) {\n *   if (schema.name && !allowed.has(schema.name)) continue\n *   // generate schema\n * }\n * ```\n */\nexport function collectUsedSchemaNames(operations: ReadonlyArray<OperationNode>, schemas: ReadonlyArray<SchemaNode>): Set<string> {\n  return collectUsedSchemaNamesMemo(operations)(schemas)\n}\n\nconst EMPTY_CIRCULAR_SET = new Set<string>()\n\nconst findCircularSchemasMemo = memoize(new WeakMap<ReadonlyArray<SchemaNode>, Set<string>>(), (schemas: ReadonlyArray<SchemaNode>): Set<string> => {\n  const graph = new Map<string, Set<string>>()\n\n  for (const schema of schemas) {\n    if (!schema.name) continue\n    graph.set(schema.name, collectReferencedSchemaNames(schema))\n  }\n\n  const circular = new Set<string>()\n  for (const start of graph.keys()) {\n    const visited = new Set<string>()\n    const stack: Array<string> = [...(graph.get(start) ?? [])]\n    while (stack.length > 0) {\n      const node = stack.pop()!\n      if (node === start) {\n        circular.add(start)\n        break\n      }\n      if (visited.has(node)) continue\n      visited.add(node)\n\n      const next = graph.get(node)\n      if (next) for (const r of next) stack.push(r)\n    }\n  }\n\n  return circular\n})\n\n/**\n * Finds every schema that takes part in a circular dependency chain, including direct self-loops.\n *\n * Wrap the returned schema positions in a deferred construct (a lazy getter or `z.lazy(() => …)`) so\n * the generated code does not recurse forever. Refs are followed by name only, so the walk stays\n * linear in the size of the schema graph.\n *\n * @note Call this once on the full graph, then check individual schemas with `containsCircularRef()`.\n */\nexport function findCircularSchemas(schemas: ReadonlyArray<SchemaNode>): Set<string> {\n  if (schemas.length === 0) return EMPTY_CIRCULAR_SET\n  return findCircularSchemasMemo(schemas)\n}\n\n/**\n * Returns `true` when a schema, or anything nested inside it, references a circular schema.\n *\n * Pass `excludeName` to skip refs to a specific schema, which helps when self-references are handled\n * on their own. Pair it with `findCircularSchemas()` to decide where lazy wrappers go.\n *\n * @note Stops at the first matching circular ref.\n */\nexport function containsCircularRef(\n  node: SchemaNode | undefined,\n  { circularSchemas, excludeName }: { circularSchemas: ReadonlySet<string>; excludeName?: string },\n): boolean {\n  if (!node || circularSchemas.size === 0) return false\n\n  for (const _ of collectLazy<true>(node, {\n    schema(child) {\n      if (child.type !== 'ref') return null\n      const name = resolveRefName(child)\n      return name && name !== excludeName && circularSchemas.has(name) ? true : null\n    },\n  })) {\n    return true\n  }\n\n  return false\n}\n","import type { ArraySchemaNode, IntersectionSchemaNode, ObjectSchemaNode, PropertyNode, SchemaNode, UnionSchemaNode } from '../nodes/index.ts'\nimport { objectKey } from './codegen.ts'\n\n/**\n * Converts a child schema to printer output. Plugins instantiate it with their own output type:\n * `string` for the zod and faker printers, `ts.TypeNode` for the TypeScript printer. A printer's\n * `this.transform` fits directly, so its `null` for an empty result carries through to `output`.\n */\nexport type SchemaTransform<TOutput> = (schema: SchemaNode) => TOutput\n\n/**\n * A union or intersection member, or an array or tuple item, paired with its transformed output.\n */\nexport type MappedSchema<TOutput> = {\n  /**\n   * The original child schema, kept so the printer can read its metadata for leaf formatting.\n   */\n  schema: SchemaNode\n  /**\n   * The child schema after being run through the transform.\n   */\n  output: TOutput\n}\n\n/**\n * An object property paired with its transformed output.\n */\nexport type MappedProperty<TOutput> = {\n  /**\n   * The property name as written on the schema, before any identifier quoting.\n   */\n  name: string\n  /**\n   * The original property node, kept so the printer can read `required`, `schema`, and metadata.\n   */\n  property: PropertyNode\n  /**\n   * The property schema after being run through the transform.\n   */\n  output: TOutput\n}\n\n/**\n * Maps each property of an object schema to its transformed output. Pairs every result with the\n * original property so the printer keeps full control over modifiers, getters, and key syntax.\n *\n * @example\n * ```ts\n * const entries = mapSchemaProperties(node, (schema) => this.transform(schema))\n * // entries: [{ name: 'id', property, output: 'z.number()' }, ...]\n * ```\n */\nexport function mapSchemaProperties<TOutput>(node: ObjectSchemaNode, transform: SchemaTransform<TOutput>): Array<MappedProperty<TOutput>> {\n  return node.properties.map((property) => ({ name: property.name, property, output: transform(property.schema) }))\n}\n\n/**\n * Maps each member of a union or intersection schema to its transformed output, pairing every\n * result with the original member.\n */\nexport function mapSchemaMembers<TOutput>(node: UnionSchemaNode | IntersectionSchemaNode, transform: SchemaTransform<TOutput>): Array<MappedSchema<TOutput>> {\n  return (node.members ?? []).map((schema) => ({ schema, output: transform(schema) }))\n}\n\n/**\n * Maps each item of an array or tuple schema to its transformed output, pairing every result with\n * the original item.\n */\nexport function mapSchemaItems<TOutput>(node: ArraySchemaNode, transform: SchemaTransform<TOutput>): Array<MappedSchema<TOutput>> {\n  return (node.items ?? []).map((schema) => ({ schema, output: transform(schema) }))\n}\n\n/**\n * Emits a lazy getter for a circular-ref property position, `get name() { return body }`. The key\n * is quoted only when it is not a valid identifier. Used by the string printers to defer evaluation\n * of a recursive schema until first access.\n *\n * @example\n * ```ts\n * lazyGetter({ name: 'parent', body: 'z.lazy(() => Pet)' })\n * // \"get parent() { return z.lazy(() => Pet) }\"\n * ```\n */\nexport function lazyGetter({ name, body }: { name: string; body: string }): string {\n  return `get ${objectKey(name)}() { return ${body} }`\n}\n","import { camelCase, isValidVarName, memoize } from '@internals/utils'\nimport { createFunctionParameter, createFunctionParameters, createIndexedAccessType, createTypeLiteral } from '../nodes/function.ts'\nimport type { FunctionParameterNode, FunctionParametersNode, OperationNode, ParameterNode, TypeExpression, TypeLiteralNode } from '../nodes/index.ts'\nimport { resolveGroupType } from './refs.ts'\n\nconst caseParamsMemo = memoize(new WeakMap<Array<ParameterNode>, (casing: string) => Array<ParameterNode>>(), (params) =>\n  memoize(new Map<string, Array<ParameterNode>>(), (casing: string) =>\n    params.map((param) => {\n      const transformed = casing === 'camelcase' || !isValidVarName(param.name) ? camelCase(param.name) : param.name\n      return { ...param, name: transformed }\n    }),\n  ),\n)\n\n/**\n * Applies casing rules to parameter names and returns a new array without mutating the input.\n *\n * Run it before handing parameters to schema builders so output property keys get the right casing\n * while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, the\n * original array is returned unchanged.\n */\nexport function caseParams(params: Array<ParameterNode>, casing: 'camelcase' | undefined): Array<ParameterNode> {\n  if (!casing) return params\n  return caseParamsMemo(params)(casing)\n}\n\n/**\n * Named type for a group of parameters (query or header) emitted as a single typed parameter.\n */\nexport type ParamGroupType = {\n  /**\n   * Type expression for the group, a plain group-name reference.\n   */\n  type: TypeExpression\n  /**\n   * Whether the parameter group is optional.\n   */\n  optional: boolean\n}\n\n/**\n * A single member of a destructured parameter group, fed to `createFunctionParameter({ properties })`.\n */\ntype GroupProperty = {\n  name: string\n  type: TypeExpression\n  optional?: boolean\n}\n\n/**\n * Resolver interface for {@link createOperationParams}.\n *\n * `ResolverTs` from `@kubb/plugin-ts` satisfies this interface and can be passed directly.\n */\nexport type OperationParamsResolver = {\n  /**\n   * Resolves the type name for an individual parameter.\n   *\n   * @example Individual path parameter name\n   * `resolver.resolveParamName(node, param) // → 'DeletePetPathPetId'`\n   */\n  resolveParamName(node: OperationNode, param: ParameterNode): string\n  /**\n   * Resolves the request body type name.\n   *\n   * @example Request body type name\n   * `resolver.resolveDataName(node) // → 'CreatePetData'`\n   */\n  resolveDataName(node: OperationNode): string\n  /**\n   * Resolves the grouped path parameters type name.\n   * When the return value equals `resolveParamName`, no indexed access is emitted.\n   *\n   * @example Grouped path params type name\n   * `resolver.resolvePathParamsName(node, param) // → 'DeletePetPathParams'`\n   */\n  resolvePathParamsName(node: OperationNode, param: ParameterNode): string\n  /**\n   * Resolves the grouped query parameters type name.\n   * When the return value equals `resolveParamName`, an inline struct type is emitted instead.\n   *\n   * @example Grouped query params type name\n   * `resolver.resolveQueryParamsName(node, param) // → 'FindPetsByStatusQueryParams'`\n   */\n  resolveQueryParamsName(node: OperationNode, param: ParameterNode): string\n  /**\n   * Resolves the grouped header parameters type name.\n   * When the return value equals `resolveParamName`, an inline struct type is emitted instead.\n   *\n   * @example Grouped header params type name\n   * `resolver.resolveHeaderParamsName(node, param) // → 'DeletePetHeaderParams'`\n   */\n  resolveHeaderParamsName(node: OperationNode, param: ParameterNode): string\n}\n\n/**\n * Options for {@link createOperationParams}.\n */\nexport type CreateOperationParamsOptions = {\n  /**\n   * How all operation parameters are grouped in the function signature.\n   * - `'object'` wraps all params into a single destructured object `{ petId, data, params }`\n   * - `'inline'` emits each param category as a separate top-level parameter\n   */\n  paramsType: 'object' | 'inline'\n  /**\n   * How path parameters are emitted when `paramsType` is `'inline'`.\n   * - `'object'` groups them as `{ petId, storeId }: PathParams`\n   * - `'inline'` spreads them as individual parameters `petId: string, storeId: string`\n   * - `'inlineSpread'` emits a single rest parameter `...pathParams: PathParams`\n   */\n  pathParamsType: 'object' | 'inline' | 'inlineSpread'\n  /**\n   * Converts parameter names to camelCase before output.\n   */\n  paramsCasing?: 'camelcase'\n  /**\n   * Resolver for parameter and request body type names.\n   * Pass `ResolverTs` from `@kubb/plugin-ts` directly.\n   * When omitted, falls back to the schema primitive or `'unknown'`.\n   */\n  resolver?: OperationParamsResolver\n  /**\n   * Default value for the path parameters binding when `pathParamsType` is `'object'`.\n   * Falls back to `'{}'` when all path params are optional.\n   */\n  pathParamsDefault?: string\n  /**\n   * Extra parameters appended after the standard operation parameters.\n   *\n   * @example Plugin-specific trailing parameter\n   * ```ts\n   * extraParams: [createFunctionParameter({ name: 'options', type: 'Partial<RequestOptions>', default: '{}' })]\n   * ```\n   */\n  extraParams?: Array<FunctionParameterNode>\n  /**\n   * Override the default parameter names used for body, query, header, and rest-path groups.\n   *\n   * Useful when targeting languages or frameworks with different naming conventions.\n   *\n   * @default { data: 'data', params: 'params', headers: 'headers', path: 'pathParams' }\n   */\n  paramNames?: {\n    /**\n     * Name for the request body parameter.\n     * @default 'data'\n     */\n    data?: string\n    /**\n     * Name for the query parameters group parameter.\n     * @default 'params'\n     */\n    params?: string\n    /**\n     * Name for the header parameters group parameter.\n     * @default 'headers'\n     */\n    headers?: string\n    /**\n     * Name for the rest path-parameters parameter when `pathParamsType` is `'inlineSpread'`.\n     * @default 'pathParams'\n     */\n    path?: string\n  }\n  /**\n   * Transforms every resolved type name before it lands in a parameter node, for framework-level\n   * type wrappers.\n   *\n   * @example Vue Query, wrap every parameter type with `MaybeRefOrGetter`\n   * `typeWrapper: (t) => \\`MaybeRefOrGetter<${t}>\\``\n   */\n  typeWrapper?: (type: string) => string\n}\n\n/**\n * Resolves the {@link TypeExpression} for an individual parameter.\n *\n * Without a resolver, it falls back to the schema primitive (a plain type-name string). When the\n * parameter belongs to a named group, it emits an {@link IndexedAccessTypeNode} like\n * `GroupParams['petId']`, otherwise the resolved individual name.\n */\nexport function resolveParamType({\n  node,\n  param,\n  resolver,\n}: {\n  node: OperationNode\n  param: ParameterNode\n  resolver: OperationParamsResolver | undefined\n}): TypeExpression {\n  if (!resolver) {\n    return param.schema.primitive ?? 'unknown'\n  }\n\n  const individualName = resolver.resolveParamName(node, param)\n\n  const groupLocation = param.in === 'path' || param.in === 'query' || param.in === 'header' ? param.in : undefined\n\n  const groupResolvers = {\n    path: resolver.resolvePathParamsName,\n    query: resolver.resolveQueryParamsName,\n    header: resolver.resolveHeaderParamsName,\n  } as const\n\n  const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : undefined\n\n  if (groupName && groupName !== individualName) {\n    return createIndexedAccessType({ target: groupName, key: param.name })\n  }\n\n  return individualName\n}\n\n/**\n * Converts an `OperationNode` into function parameters for code generation.\n *\n * Centralizes parameter grouping logic for all plugins. `paramsType` chooses between one\n * destructured object parameter (`object`) and separate top-level parameters (`inline`), while\n * `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type\n * name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.\n */\nexport function createOperationParams(node: OperationNode, options: CreateOperationParamsOptions): FunctionParametersNode {\n  const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options\n\n  const dataName = paramNames?.data ?? 'data'\n  const paramsName = paramNames?.params ?? 'params'\n  const headersName = paramNames?.headers ?? 'headers'\n  const pathName = paramNames?.path ?? 'pathParams'\n\n  const wrapType = (type: string): string => (typeWrapper ? typeWrapper(type) : type)\n  // typeWrapper takes a type-name string, so only plain references are wrapped.\n  // TypeLiteral and IndexedAccessType expressions are pre-resolved and pass through unchanged.\n  const wrapTypeExpression = (type: TypeExpression): TypeExpression => (typeof type === 'string' ? wrapType(type) : type)\n\n  const casedParams = caseParams(node.parameters, paramsCasing)\n  const pathParams = casedParams.filter((p) => p.in === 'path')\n  const queryParams = casedParams.filter((p) => p.in === 'query')\n  const headerParams = casedParams.filter((p) => p.in === 'header')\n\n  const toProperty = (param: ParameterNode): GroupProperty => ({\n    name: param.name,\n    type: wrapTypeExpression(resolveParamType({ node, param, resolver })),\n    optional: !param.required,\n  })\n  const emptyObjectDefault = (props: Array<GroupProperty>): string | undefined => (props.every((p) => p.optional) ? '{}' : undefined)\n\n  const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.resolveDataName(node) ?? 'unknown') : undefined\n  const bodyProperty: Array<GroupProperty> = bodyType ? [{ name: dataName, type: bodyType, optional: !(node.requestBody?.required ?? false) }] : []\n\n  const trailingGroups: Array<BuildGroupArgs> = [\n    { name: paramsName, node, params: queryParams, groupType: resolveGroupType({ node, params: queryParams, group: 'query', resolver }), resolver, wrapType },\n    {\n      name: headersName,\n      node,\n      params: headerParams,\n      groupType: resolveGroupType({ node, params: headerParams, group: 'header', resolver }),\n      resolver,\n      wrapType,\n    },\n  ]\n\n  const params: Array<FunctionParameterNode> = []\n\n  if (paramsType === 'object') {\n    const children = [...pathParams.map(toProperty), ...bodyProperty, ...trailingGroups.flatMap(buildGroupProperty)]\n    if (children.length) {\n      params.push(createFunctionParameter({ properties: children, default: emptyObjectDefault(children) }))\n    }\n  } else {\n    if (pathParamsType === 'inlineSpread' && pathParams.length) {\n      const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]!)\n      params.push(createFunctionParameter({ name: pathName, type: spreadType ? wrapType(spreadType) : undefined, rest: true }))\n    } else if (pathParamsType === 'inline') {\n      params.push(...pathParams.map((p) => createFunctionParameter(toProperty(p))))\n    } else if (pathParams.length) {\n      const pathChildren = pathParams.map(toProperty)\n      params.push(createFunctionParameter({ properties: pathChildren, default: pathParamsDefault ?? emptyObjectDefault(pathChildren) }))\n    }\n\n    params.push(...bodyProperty.map((p) => createFunctionParameter(p)))\n    params.push(...trailingGroups.flatMap(buildGroupParam))\n  }\n\n  params.push(...extraParams)\n\n  return createFunctionParameters({ params })\n}\n\n/**\n * Shared arguments for building a query or header parameter group.\n */\nexport type BuildGroupArgs = {\n  name: string\n  node: OperationNode\n  params: Array<ParameterNode>\n  groupType: ParamGroupType | null\n  resolver: OperationParamsResolver | undefined\n  wrapType: (type: string) => string\n}\n\n/**\n * Builds the property descriptor for a query or header group.\n * Returns an empty array when there are no params to emit.\n *\n * A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline\n * {@link TypeLiteralNode} from the individual params.\n */\nfunction buildGroupProperty({ name, node, params, groupType, resolver, wrapType }: BuildGroupArgs): Array<GroupProperty> {\n  if (groupType) {\n    const type = typeof groupType.type === 'string' ? wrapType(groupType.type) : groupType.type\n    return [{ name, type, optional: groupType.optional }]\n  }\n  if (params.length) {\n    return [{ name, type: buildTypeLiteral({ node, params, resolver }), optional: params.every((p) => !p.required) }]\n  }\n  return []\n}\n\n/**\n * Builds a single {@link FunctionParameterNode} for a query or header group.\n * Returns an empty array when there are no params to emit.\n *\n * A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline\n * {@link TypeLiteralNode} from the individual params.\n */\nexport function buildGroupParam(args: BuildGroupArgs): Array<FunctionParameterNode> {\n  return buildGroupProperty(args).map((p) => createFunctionParameter(p))\n}\n\n/**\n * Builds a {@link TypeLiteralNode} for an inline anonymous type grouping named fields.\n *\n * Used when query or header parameters have no dedicated group type name.\n * Each language printer renders this appropriately (TypeScript: `{ petId: string; name?: string }`).\n */\nexport function buildTypeLiteral({\n  node,\n  params,\n  resolver,\n}: {\n  node: OperationNode\n  params: Array<ParameterNode>\n  resolver: OperationParamsResolver | undefined\n}): TypeLiteralNode {\n  return createTypeLiteral({\n    members: params.map((p) => ({\n      name: p.name,\n      type: resolveParamType({ node, param: p, resolver }),\n      optional: !p.required,\n    })),\n  })\n}\n"],"mappings":"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"}

package/dist/{utils-BDI3kXlb.cjs → utils-CEepwqmb.cjs}

@@ -1,5 +1,5 @@
-const require_response = require("./response-BeG6hq2D.cjs");
-const require_visitor = require("./visitor-B7Zlnp4c.cjs");
+const require_schema = require("./schema-BkvrrOAr.cjs");
+const require_refs = require("./refs-u5SDdyV7.cjs");
 //#region ../../internals/utils/src/promise.ts
 /**
 * Wraps `factory` with a keyed cache backed by the provided store.
@@ -177,8 +177,8 @@ function singleQuote(value) {
 //#endregion
 //#region src/utils/codegen.ts
 /**
-* Builds a JSDoc comment block from an array of lines, returning `fallback` when there are no
-* comments so callers always get a usable string.
+* Builds a JSDoc comment block from an array of lines. Returns `fallback` when there are no
+* comments.
 *
 * @example
 * ```ts
@@ -196,7 +196,7 @@ function buildJSDoc(comments, options = {}) {
 */
 function indentLines(text) {
 	if (!text) return "";
-	return text.split("\n").map((line) => line.trim() ? `${require_visitor.INDENT}${line}` : "").join("\n");
+	return text.split("\n").map((line) => line.trim() ? `${require_refs.INDENT}${line}` : "").join("\n");
 }
 /**
 * Renders an object key, quoting it with single quotes only when it is not a valid identifier.
@@ -213,9 +213,8 @@ function objectKey(name) {
 }
 /**
 * Assembles a multi-line object literal from already-rendered `entries`, indenting each entry one
-* level and closing the brace at column zero. Nested objects built the same way indent cumulatively,
-* so callers never re-parse the generated code. A trailing comma is added per entry to match the
-* formatter's multi-line style.
+* level and closing the brace at column zero. Entries that are themselves multi-line objects indent
+* cumulatively. Each entry ends with a trailing comma to match the formatter's multi-line style.
 *
 * @example
 * ```ts
@@ -230,8 +229,8 @@ function buildObject(entries) {
 /**
 * Assembles a bracketed list (array by default) from already-rendered `items`. Keeps everything on
 * one line when no item spans multiple lines, and otherwise puts each item on its own line, indented
-* one level with a trailing comma and the closing bracket at column zero. Use it for `z.union([…])`,
-* `z.array([…])`, and similar member lists so objects inside them nest correctly.
+* one level with a trailing comma and the closing bracket at column zero. Used for member lists such
+* as `z.union([…])` and `z.array([…])`.
 *
 * @example
 * ```ts
@@ -249,8 +248,8 @@ function buildList(items, brackets = ["[", "]"]) {
 //#region src/utils/schemaMerge.ts
 /**
 * Merges a run of adjacent anonymous object members into one. Named or non-object members break the
-* run and pass through. Stays a construction-time helper, not a macro, so callers keep control of the
-* member boundaries (such as keeping synthetic discriminant objects out of a run).
+* run and pass through unchanged. The merge follows member order, so callers control which members
+* combine by where they place them in the sequence.
 *
 * @example
 * ```ts
@@ -260,11 +259,11 @@ function buildList(items, brackets = ["[", "]"]) {
 function* mergeAdjacentObjectsLazy(members) {
 	let acc;
 	for (const member of members) {
-		const objectMember = require_visitor.narrowSchema(member, "object");
+		const objectMember = require_refs.narrowSchema(member, "object");
 		if (objectMember && !objectMember.name && acc !== void 0) {
-			const accObject = require_visitor.narrowSchema(acc, "object");
+			const accObject = require_refs.narrowSchema(acc, "object");
 			if (accObject && !accObject.name) {
-				acc = require_response.createSchema({
+				acc = require_schema.createSchema({
 					...accObject,
 					properties: [...accObject.properties ?? [], ...objectMember.properties ?? []]
 				});
@@ -393,14 +392,28 @@ function getNestedAccessor(param, accessor) {
 //#endregion
 //#region src/utils/schemaGraph.ts
 /**
-* Collects every named schema referenced transitively from a node through its ref edges.
+* Memoized inner pass that walks a single node and returns the names of every schema it references.
+*/
+const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
+	const refs = /* @__PURE__ */ new Set();
+	require_refs.collect(node, { schema(child) {
+		if (child.type === "ref") {
+			const name = require_refs.resolveRefName(child);
+			if (name) refs.add(name);
+		}
+	} });
+	return refs;
+});
+/**
+* Collects the names of every ref found anywhere inside a node's own subtree.
 *
-* Refs are followed by name only, so the resolved `node.schema` is never traversed inline.
+* Each ref contributes its name only, so the schema it points to is never traversed here. Pass `out`
+* to accumulate names from several nodes into one set.
 *
 * @example Collect refs from a single schema
 * ```ts
 * const names = collectReferencedSchemaNames(petSchema)
-* // → Set { 'Category', 'Tag' }
+* // Set { 'Category', 'Tag' }
 * ```
 *
 * @example Accumulate refs from multiple schemas into one set
@@ -411,39 +424,13 @@ function getNestedAccessor(param, accessor) {
 * }
 * ```
 */
-const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
-	const refs = /* @__PURE__ */ new Set();
-	require_visitor.collect(node, { schema(child) {
-		if (child.type === "ref") {
-			const name = require_visitor.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 its parameters, request body, or responses reference it, directly
-* or through other named schemas. The walk is iterative, so reference cycles are safe.
-*
-* Pair it with `include` filters so schemas reachable only from excluded operations stay ungenerated.
-*
-* @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
-* }
-* ```
+* Memoized two-level cache keyed first on the operations array, then on the schemas array.
 */
 const collectUsedSchemaNamesMemo = memoize(/* @__PURE__ */ new WeakMap(), (ops) => memoize(/* @__PURE__ */ new WeakMap(), (schemas) => computeUsedSchemaNames(ops, schemas)));
 function computeUsedSchemaNames(operations, schemas) {
@@ -458,12 +445,32 @@ function computeUsedSchemaNames(operations, schemas) {
 			if (namedSchema) visitSchema(namedSchema);
 		}
 	}
-	for (const op of operations) for (const schema of require_visitor.collectLazy(op, {
+	for (const op of operations) for (const schema of require_refs.collectLazy(op, {
 		depth: "shallow",
 		schema: (node) => node
 	})) visitSchema(schema);
 	return result;
 }
+/**
+* Collects the names of all top-level schemas transitively used by a set of operations.
+*
+* An operation uses a schema when its parameters, request body, or responses reference it, directly
+* or through other named schemas. Once a name is added to the result it is not revisited, so
+* reference cycles terminate.
+*
+* Pair it with `include` filters so schemas reachable only from excluded operations stay ungenerated.
+*
+* @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
+* }
+* ```
+*/
 function collectUsedSchemaNames(operations, schemas) {
 	return collectUsedSchemaNamesMemo(operations)(schemas);
 }
@@ -515,9 +522,9 @@ function findCircularSchemas(schemas) {
 */
 function containsCircularRef(node, { circularSchemas, excludeName }) {
 	if (!node || circularSchemas.size === 0) return false;
-	for (const _ of require_visitor.collectLazy(node, { schema(child) {
+	for (const _ of require_refs.collectLazy(node, { schema(child) {
 		if (child.type !== "ref") return null;
-		const name = require_visitor.resolveRefName(child);
+		const name = require_refs.resolveRefName(child);
 		return name && name !== excludeName && circularSchemas.has(name) ? true : null;
 	} })) return true;
 	return false;
@@ -577,6 +584,13 @@ function lazyGetter({ name, body }) {
 }
 //#endregion
 //#region src/utils/operationParams.ts
+const caseParamsMemo = memoize(/* @__PURE__ */ new WeakMap(), (params) => memoize(/* @__PURE__ */ new Map(), (casing) => params.map((param) => {
+	const transformed = casing === "camelcase" || !isValidVarName(param.name) ? require_schema.camelCase(param.name) : param.name;
+	return {
+		...param,
+		name: transformed
+	};
+})));
 /**
 * Applies casing rules to parameter names and returns a new array without mutating the input.
 *
@@ -584,13 +598,6 @@ function lazyGetter({ name, body }) {
 * while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, 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" || !isValidVarName(param.name) ? require_response.camelCase(param.name) : param.name;
-	return {
-		...param,
-		name: transformed
-	};
-})));
 function caseParams(params, casing) {
 	if (!casing) return params;
 	return caseParamsMemo(params)(casing);
@@ -612,7 +619,7 @@ function resolveParamType({ node, param, resolver }) {
 		header: resolver.resolveHeaderParamsName
 	};
 	const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : void 0;
-	if (groupName && groupName !== individualName) return require_response.createIndexedAccessType({
+	if (groupName && groupName !== individualName) return require_schema.createIndexedAccessType({
 		target: groupName,
 		key: param.name
 	});
@@ -658,7 +665,7 @@ function createOperationParams(node, options) {
 		name: paramsName,
 		node,
 		params: queryParams,
-		groupType: require_visitor.resolveGroupType({
+		groupType: require_refs.resolveGroupType({
 			node,
 			params: queryParams,
 			group: "query",
@@ -670,7 +677,7 @@ function createOperationParams(node, options) {
 		name: headersName,
 		node,
 		params: headerParams,
-		groupType: require_visitor.resolveGroupType({
+		groupType: require_refs.resolveGroupType({
 			node,
 			params: headerParams,
 			group: "header",
@@ -686,31 +693,31 @@ function createOperationParams(node, options) {
 			...bodyProperty,
 			...trailingGroups.flatMap(buildGroupProperty)
 		];
-		if (children.length) params.push(require_response.createFunctionParameter({
+		if (children.length) params.push(require_schema.createFunctionParameter({
 			properties: children,
 			default: emptyObjectDefault(children)
 		}));
 	} else {
 		if (pathParamsType === "inlineSpread" && pathParams.length) {
 			const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]);
-			params.push(require_response.createFunctionParameter({
+			params.push(require_schema.createFunctionParameter({
 				name: pathName,
 				type: spreadType ? wrapType(spreadType) : void 0,
 				rest: true
 			}));
-		} else if (pathParamsType === "inline") params.push(...pathParams.map((p) => require_response.createFunctionParameter(toProperty(p))));
+		} else if (pathParamsType === "inline") params.push(...pathParams.map((p) => require_schema.createFunctionParameter(toProperty(p))));
 		else if (pathParams.length) {
 			const pathChildren = pathParams.map(toProperty);
-			params.push(require_response.createFunctionParameter({
+			params.push(require_schema.createFunctionParameter({
 				properties: pathChildren,
 				default: pathParamsDefault ?? emptyObjectDefault(pathChildren)
 			}));
 		}
-		params.push(...bodyProperty.map((p) => require_response.createFunctionParameter(p)));
+		params.push(...bodyProperty.map((p) => require_schema.createFunctionParameter(p)));
 		params.push(...trailingGroups.flatMap(buildGroupParam));
 	}
 	params.push(...extraParams);
-	return require_response.createFunctionParameters({ params });
+	return require_schema.createFunctionParameters({ params });
 }
 /**
 * Builds the property descriptor for a query or header group.
@@ -744,7 +751,7 @@ function buildGroupProperty({ name, node, params, groupType, resolver, wrapType
 * {@link TypeLiteralNode} from the individual params.
 */
 function buildGroupParam(args) {
-	return buildGroupProperty(args).map((p) => require_response.createFunctionParameter(p));
+	return buildGroupProperty(args).map((p) => require_schema.createFunctionParameter(p));
 }
 /**
 * Builds a {@link TypeLiteralNode} for an inline anonymous type grouping named fields.
@@ -753,7 +760,7 @@ function buildGroupParam(args) {
 * Each language printer renders this appropriately (TypeScript: `{ petId: string; name?: string }`).
 */
 function buildTypeLiteral({ node, params, resolver }) {
-	return require_response.createTypeLiteral({ members: params.map((p) => ({
+	return require_schema.createTypeLiteral({ members: params.map((p) => ({
 		name: p.name,
 		type: resolveParamType({
 			node,
@@ -909,4 +916,4 @@ Object.defineProperty(exports, "trimQuotes", {
 	}
 });
 
-//# sourceMappingURL=utils-BDI3kXlb.cjs.map
+//# sourceMappingURL=utils-CEepwqmb.cjs.map