@kubb/ast 5.0.0-beta.61 → 5.0.0-beta.63

package/dist/{defineMacro-BLIR6k-j.d.ts → defineMacro-BATi7xoC.d.ts}

@@ -1,5 +1,5 @@
 import { n as __name } from "./chunk-CNktS9qV.js";
-import { Et as PropertyNode, _t as SchemaNode, f as OperationNode, h as ResponseNode, n as OutputNode, nt as ContentNode, o as InputNode, t as Node, w as ParameterNode, y as RequestBodyNode } from "./index-BzjwdK2M.js";
+import { C as ParameterNode, Et as PropertyNode, _t as SchemaNode, f as OperationNode, h as ResponseNode, n as OutputNode, o as InputNode, rt as ContentNode, t as Node, y as RequestBodyNode } from "./index-B9cc8MBS.js";
 
 //#region src/constants.d.ts
 /**
@@ -13,7 +13,6 @@ type VisitorDepth = 'shallow' | 'deep';
  * Schema type discriminators used by all AST schema nodes.
  *
  * Each value is a stable discriminator across the AST (for example `schema.type === schemaTypes.object`).
- * Call `isScalarPrimitive()` to check for the scalar types.
  */
 declare const schemaTypes: {
   /**
@@ -121,19 +120,6 @@ declare const schemaTypes: {
    */
   readonly never: "never";
 };
-/**
- * HTTP method identifiers used by operation nodes.
- */
-declare const httpMethods: {
-  readonly get: "GET";
-  readonly post: "POST";
-  readonly put: "PUT";
-  readonly patch: "PATCH";
-  readonly delete: "DELETE";
-  readonly head: "HEAD";
-  readonly options: "OPTIONS";
-  readonly trace: "TRACE";
-};
 //#endregion
 //#region src/visitor.d.ts
 /**
@@ -162,7 +148,7 @@ type ParentNodeMap = [[InputNode, undefined], [OutputNode, undefined], [Operatio
  * @example
  * ```ts
  * type SchemaParent = ParentOf<SchemaNode>
- * // InputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode
+ * // InputNode | ContentNode | SchemaNode | PropertyNode | ParameterNode
  * ```
  */
 type ParentOf<T extends Node, TEntries extends ReadonlyArray<[Node, unknown]> = ParentNodeMap> = TEntries extends [infer TEntry extends [Node, unknown], ...infer TRest extends ReadonlyArray<[Node, unknown]>] ? T extends TEntry[0] ? TEntry[1] : ParentOf<T, TRest> : Node;
@@ -402,6 +388,11 @@ declare function transform(node: Node, options: TransformOptions): Node;
 declare function collect<T>(node: Node, options: CollectOptions<T>): Array<T>;
 //#endregion
 //#region src/defineMacro.d.ts
+/**
+ * Ordering hint shared by macros and plugins. `pre` runs before unmarked items, `post` after,
+ * and `undefined` keeps declaration order.
+ */
+type Enforce = 'pre' | 'post';
 /**
  * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a
  * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an
@@ -410,14 +401,14 @@ declare function collect<T>(node: Node, options: CollectOptions<T>): Array<T>;
  */
 type Macro = Visitor & {
   /**
-   * Macro identifier, surfaced in diagnostics. Follows the `macro<Name>` convention.
+   * Macro identifier used to tell macros apart, for example `'simplify-union'`.
    */
   name: string;
   /**
    * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.
    * Ordering within a bucket follows list order.
    */
-  enforce?: 'pre' | 'post';
+  enforce?: Enforce;
   /**
    * Gate checked against the current node before any callback runs. When it returns `false`
    * the macro is skipped for that node.
@@ -471,5 +462,5 @@ declare function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyAr
   depth?: VisitorDepth;
 }): TNode;
 //#endregion
-export { ParentOf as a, collect as c, httpMethods as d, schemaTypes as f, defineMacro as i, transform as l, applyMacros as n, Visitor as o, composeMacros as r, VisitorContext as s, Macro as t, walk as u };
-//# sourceMappingURL=defineMacro-BLIR6k-j.d.ts.map
+export { defineMacro as a, VisitorContext as c, walk as d, schemaTypes as f, composeMacros as i, collect as l, Macro as n, ParentOf as o, applyMacros as r, Visitor as s, Enforce as t, transform as u };
+//# sourceMappingURL=defineMacro-BATi7xoC.d.ts.map

package/dist/{defineMacro-Bv9R_9a2.cjs → defineMacro-CEZHaCXE.cjs}

@@ -1,20 +1,7 @@
-require("./response-hnSw2NKE.cjs");
-const require_visitor = require("./visitor-DpKZ9Tk0.cjs");
+const require_schema = require("./schema-BkvrrOAr.cjs");
+const require_refs = require("./refs-u5SDdyV7.cjs");
 //#region src/defineMacro.ts
 /**
-* Visitor callback names a macro can implement, one per traversable node kind.
-* Mirrors the keys of {@link Visitor}.
-*/
-const macroKeys = [
-	"input",
-	"output",
-	"operation",
-	"schema",
-	"property",
-	"parameter",
-	"response"
-];
-/**
 * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain
 * list keeps its authored order.
 */
@@ -45,7 +32,7 @@ function defineMacro(macro) {
 * the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the
 * original reference (structural sharing).
 */
-function chain(macros, key, node, context) {
+function chain({ macros, key, node, context }) {
 	let current = node;
 	for (const macro of macros) {
 		const callback = macro[key];
@@ -71,9 +58,14 @@ function chain(macros, key, node, context) {
 function composeMacros(macros) {
 	const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce));
 	const visitor = {};
-	for (const key of macroKeys) {
+	for (const key of require_schema.visitorKeys) {
 		if (!ordered.some((macro) => typeof macro[key] === "function")) continue;
-		const callback = (node, context) => chain(ordered, key, node, context);
+		const callback = (node, context) => chain({
+			macros: ordered,
+			key,
+			node,
+			context
+		});
 		visitor[key] = callback;
 	}
 	return visitor;
@@ -95,9 +87,9 @@ function composeMacros(macros) {
 */
 function applyMacros(root, macros, options) {
 	if (macros.length === 0) return root;
-	return require_visitor.transform(root, {
+	return require_refs.transform(root, {
 		...composeMacros(macros),
-		depth: options?.depth
+		...options
 	});
 }
 //#endregion
@@ -120,4 +112,4 @@ Object.defineProperty(exports, "defineMacro", {
 	}
 });
 
-//# sourceMappingURL=defineMacro-Bv9R_9a2.cjs.map
+//# sourceMappingURL=defineMacro-CEZHaCXE.cjs.map

package/dist/defineMacro-CEZHaCXE.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineMacro-CEZHaCXE.cjs","names":["visitorKeys","transform"],"sources":["../src/defineMacro.ts"],"sourcesContent":["import type { VisitorDepth } from './constants.ts'\nimport type { VisitorKey } from './defineNode.ts'\nimport { visitorKeys } from './defineNode.ts'\nimport type { Node } from './nodes/index.ts'\nimport type { Visitor, VisitorContext } from './visitor.ts'\nimport { transform } from './visitor.ts'\n\n/**\n * Ordering hint shared by macros and plugins. `pre` runs before unmarked items, `post` after,\n * and `undefined` keeps declaration order.\n */\nexport type Enforce = 'pre' | 'post'\n\n/**\n * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain\n * list keeps its authored order.\n */\nfunction enforceWeight(enforce?: Enforce): number {\n  if (enforce === 'pre') return 0\n  if (enforce === 'post') return 2\n  return 1\n}\n\n/**\n * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a\n * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an\n * optional `when` gate. Macros run on the shared AST, so the same macro works across every adapter\n * and output target. Exports follow the `macro<Name>` convention, mirroring plugins (`pluginTs`).\n */\nexport type Macro = Visitor & {\n  /**\n   * Macro identifier used to tell macros apart, for example `'simplify-union'`.\n   */\n  name: string\n  /**\n   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.\n   * Ordering within a bucket follows list order.\n   */\n  enforce?: Enforce\n  /**\n   * Gate checked against the current node before any callback runs. When it returns `false`\n   * the macro is skipped for that node.\n   */\n  when?: (node: Node) => boolean\n}\n\n/**\n * Types a macro for inference and a single construction site, mirroring `definePlugin`.\n * Adds no runtime behavior.\n *\n * @example\n * ```ts\n * const macroUntagged = defineMacro({\n *   name: 'untagged',\n *   operation(node) {\n *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }\n *   },\n * })\n * ```\n */\nexport function defineMacro(macro: Macro): Macro {\n  return macro\n}\n\ntype MacroCallback = (node: Node, context: VisitorContext) => Node | null | undefined\n\ntype ChainProps = {\n  macros: ReadonlyArray<Macro>\n  key: VisitorKey\n  node: Node\n  context: VisitorContext\n}\n\n/**\n * Runs every macro's callback for one node kind in order, chaining the result so each macro sees\n * the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the\n * original reference (structural sharing).\n */\nfunction chain({ macros, key, node, context }: ChainProps): Node | undefined {\n  let current = node\n\n  for (const macro of macros) {\n    const callback = macro[key] as MacroCallback | undefined\n    if (!callback) continue\n    if (macro.when && !macro.when(current)) continue\n\n    const next = callback(current, context)\n    if (next != null) current = next\n  }\n\n  return current === node ? undefined : current\n}\n\n/**\n * Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin\n * transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied\n * sequentially per node so later macros see earlier output. This differs from a plain visitor, which\n * has no names, ordering, or composition.\n *\n * @example\n * ```ts\n * const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])\n * const next = transform(root, visitor)\n * ```\n */\nexport function composeMacros(macros: ReadonlyArray<Macro>): Visitor {\n  const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce))\n\n  const visitor: Visitor = {}\n  for (const key of visitorKeys) {\n    if (!ordered.some((macro) => typeof macro[key] === 'function')) continue\n\n    const callback = (node: Node, context: VisitorContext) => chain({ macros: ordered, key, node, context })\n    ;(visitor as Record<VisitorKey, MacroCallback>)[key] = callback\n  }\n\n  return visitor\n}\n\n/**\n * Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s\n * structural sharing, so an empty or no-op macro list returns the same reference. Pass\n * `depth: 'shallow'` to rewrite the root node only.\n *\n * @example\n * ```ts\n * const next = applyMacros(root, [macroIntegerToString])\n * ```\n *\n * @example Apply to the root node only\n * ```ts\n * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })\n * ```\n */\nexport function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: { depth?: VisitorDepth }): TNode {\n  if (macros.length === 0) return root\n\n  return transform(root, { ...composeMacros(macros), ...options }) as TNode\n}\n"],"mappings":";;;;;;;AAiBA,SAAS,cAAc,SAA2B;CAChD,IAAI,YAAY,OAAO,OAAO;CAC9B,IAAI,YAAY,QAAQ,OAAO;CAC/B,OAAO;AACT;;;;;;;;;;;;;;;AAuCA,SAAgB,YAAY,OAAqB;CAC/C,OAAO;AACT;;;;;;AAgBA,SAAS,MAAM,EAAE,QAAQ,KAAK,MAAM,WAAyC;CAC3E,IAAI,UAAU;CAEd,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM;EACvB,IAAI,CAAC,UAAU;EACf,IAAI,MAAM,QAAQ,CAAC,MAAM,KAAK,OAAO,GAAG;EAExC,MAAM,OAAO,SAAS,SAAS,OAAO;EACtC,IAAI,QAAQ,MAAM,UAAU;CAC9B;CAEA,OAAO,YAAY,OAAO,KAAA,IAAY;AACxC;;;;;;;;;;;;;AAcA,SAAgB,cAAc,QAAuC;CACnE,MAAM,UAAU,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,GAAG,MAAM,cAAc,EAAE,OAAO,IAAI,cAAc,EAAE,OAAO,CAAC;CAE9F,MAAM,UAAmB,CAAC;CAC1B,KAAK,MAAM,OAAOA,eAAAA,aAAa;EAC7B,IAAI,CAAC,QAAQ,MAAM,UAAU,OAAO,MAAM,SAAS,UAAU,GAAG;EAEhE,MAAM,YAAY,MAAY,YAA4B,MAAM;GAAE,QAAQ;GAAS;GAAK;GAAM;EAAQ,CAAC;EACtG,QAA+C,OAAO;CACzD;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAgC,MAAa,QAA8B,SAA2C;CACpI,IAAI,OAAO,WAAW,GAAG,OAAO;CAEhC,OAAOC,aAAAA,UAAU,MAAM;EAAE,GAAG,cAAc,MAAM;EAAG,GAAG;CAAQ,CAAC;AACjE"}

package/dist/{defineMacro-BTXvS8nI.js → defineMacro-Shz8f6SG.js}

@@ -1,20 +1,8 @@
 import "./chunk-CNktS9qV.js";
-import { r as transform } from "./visitor-DJ6ZEJvq.js";
+import { u as transform } from "./refs-BjNDuCBD.js";
+import { nt as visitorKeys } from "./schema-Cbnxmz4b.js";
 //#region src/defineMacro.ts
 /**
-* Visitor callback names a macro can implement, one per traversable node kind.
-* Mirrors the keys of {@link Visitor}.
-*/
-const macroKeys = [
-	"input",
-	"output",
-	"operation",
-	"schema",
-	"property",
-	"parameter",
-	"response"
-];
-/**
 * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain
 * list keeps its authored order.
 */
@@ -45,7 +33,7 @@ function defineMacro(macro) {
 * the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the
 * original reference (structural sharing).
 */
-function chain(macros, key, node, context) {
+function chain({ macros, key, node, context }) {
 	let current = node;
 	for (const macro of macros) {
 		const callback = macro[key];
@@ -71,9 +59,14 @@ function chain(macros, key, node, context) {
 function composeMacros(macros) {
 	const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce));
 	const visitor = {};
-	for (const key of macroKeys) {
+	for (const key of visitorKeys) {
 		if (!ordered.some((macro) => typeof macro[key] === "function")) continue;
-		const callback = (node, context) => chain(ordered, key, node, context);
+		const callback = (node, context) => chain({
+			macros: ordered,
+			key,
+			node,
+			context
+		});
 		visitor[key] = callback;
 	}
 	return visitor;
@@ -97,10 +90,10 @@ function applyMacros(root, macros, options) {
 	if (macros.length === 0) return root;
 	return transform(root, {
 		...composeMacros(macros),
-		depth: options?.depth
+		...options
 	});
 }
 //#endregion
 export { composeMacros as n, defineMacro as r, applyMacros as t };
 
-//# sourceMappingURL=defineMacro-BTXvS8nI.js.map
+//# sourceMappingURL=defineMacro-Shz8f6SG.js.map

package/dist/defineMacro-Shz8f6SG.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineMacro-Shz8f6SG.js","names":[],"sources":["../src/defineMacro.ts"],"sourcesContent":["import type { VisitorDepth } from './constants.ts'\nimport type { VisitorKey } from './defineNode.ts'\nimport { visitorKeys } from './defineNode.ts'\nimport type { Node } from './nodes/index.ts'\nimport type { Visitor, VisitorContext } from './visitor.ts'\nimport { transform } from './visitor.ts'\n\n/**\n * Ordering hint shared by macros and plugins. `pre` runs before unmarked items, `post` after,\n * and `undefined` keeps declaration order.\n */\nexport type Enforce = 'pre' | 'post'\n\n/**\n * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain\n * list keeps its authored order.\n */\nfunction enforceWeight(enforce?: Enforce): number {\n  if (enforce === 'pre') return 0\n  if (enforce === 'post') return 2\n  return 1\n}\n\n/**\n * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a\n * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an\n * optional `when` gate. Macros run on the shared AST, so the same macro works across every adapter\n * and output target. Exports follow the `macro<Name>` convention, mirroring plugins (`pluginTs`).\n */\nexport type Macro = Visitor & {\n  /**\n   * Macro identifier used to tell macros apart, for example `'simplify-union'`.\n   */\n  name: string\n  /**\n   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.\n   * Ordering within a bucket follows list order.\n   */\n  enforce?: Enforce\n  /**\n   * Gate checked against the current node before any callback runs. When it returns `false`\n   * the macro is skipped for that node.\n   */\n  when?: (node: Node) => boolean\n}\n\n/**\n * Types a macro for inference and a single construction site, mirroring `definePlugin`.\n * Adds no runtime behavior.\n *\n * @example\n * ```ts\n * const macroUntagged = defineMacro({\n *   name: 'untagged',\n *   operation(node) {\n *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }\n *   },\n * })\n * ```\n */\nexport function defineMacro(macro: Macro): Macro {\n  return macro\n}\n\ntype MacroCallback = (node: Node, context: VisitorContext) => Node | null | undefined\n\ntype ChainProps = {\n  macros: ReadonlyArray<Macro>\n  key: VisitorKey\n  node: Node\n  context: VisitorContext\n}\n\n/**\n * Runs every macro's callback for one node kind in order, chaining the result so each macro sees\n * the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the\n * original reference (structural sharing).\n */\nfunction chain({ macros, key, node, context }: ChainProps): Node | undefined {\n  let current = node\n\n  for (const macro of macros) {\n    const callback = macro[key] as MacroCallback | undefined\n    if (!callback) continue\n    if (macro.when && !macro.when(current)) continue\n\n    const next = callback(current, context)\n    if (next != null) current = next\n  }\n\n  return current === node ? undefined : current\n}\n\n/**\n * Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin\n * transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied\n * sequentially per node so later macros see earlier output. This differs from a plain visitor, which\n * has no names, ordering, or composition.\n *\n * @example\n * ```ts\n * const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])\n * const next = transform(root, visitor)\n * ```\n */\nexport function composeMacros(macros: ReadonlyArray<Macro>): Visitor {\n  const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce))\n\n  const visitor: Visitor = {}\n  for (const key of visitorKeys) {\n    if (!ordered.some((macro) => typeof macro[key] === 'function')) continue\n\n    const callback = (node: Node, context: VisitorContext) => chain({ macros: ordered, key, node, context })\n    ;(visitor as Record<VisitorKey, MacroCallback>)[key] = callback\n  }\n\n  return visitor\n}\n\n/**\n * Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s\n * structural sharing, so an empty or no-op macro list returns the same reference. Pass\n * `depth: 'shallow'` to rewrite the root node only.\n *\n * @example\n * ```ts\n * const next = applyMacros(root, [macroIntegerToString])\n * ```\n *\n * @example Apply to the root node only\n * ```ts\n * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })\n * ```\n */\nexport function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: { depth?: VisitorDepth }): TNode {\n  if (macros.length === 0) return root\n\n  return transform(root, { ...composeMacros(macros), ...options }) as TNode\n}\n"],"mappings":";;;;;;;;AAiBA,SAAS,cAAc,SAA2B;CAChD,IAAI,YAAY,OAAO,OAAO;CAC9B,IAAI,YAAY,QAAQ,OAAO;CAC/B,OAAO;AACT;;;;;;;;;;;;;;;AAuCA,SAAgB,YAAY,OAAqB;CAC/C,OAAO;AACT;;;;;;AAgBA,SAAS,MAAM,EAAE,QAAQ,KAAK,MAAM,WAAyC;CAC3E,IAAI,UAAU;CAEd,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM;EACvB,IAAI,CAAC,UAAU;EACf,IAAI,MAAM,QAAQ,CAAC,MAAM,KAAK,OAAO,GAAG;EAExC,MAAM,OAAO,SAAS,SAAS,OAAO;EACtC,IAAI,QAAQ,MAAM,UAAU;CAC9B;CAEA,OAAO,YAAY,OAAO,KAAA,IAAY;AACxC;;;;;;;;;;;;;AAcA,SAAgB,cAAc,QAAuC;CACnE,MAAM,UAAU,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,GAAG,MAAM,cAAc,EAAE,OAAO,IAAI,cAAc,EAAE,OAAO,CAAC;CAE9F,MAAM,UAAmB,CAAC;CAC1B,KAAK,MAAM,OAAO,aAAa;EAC7B,IAAI,CAAC,QAAQ,MAAM,UAAU,OAAO,MAAM,SAAS,UAAU,GAAG;EAEhE,MAAM,YAAY,MAAY,YAA4B,MAAM;GAAE,QAAQ;GAAS;GAAK;GAAM;EAAQ,CAAC;EACtG,QAA+C,OAAO;CACzD;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAgC,MAAa,QAA8B,SAA2C;CACpI,IAAI,OAAO,WAAW,GAAG,OAAO;CAEhC,OAAO,UAAU,MAAM;EAAE,GAAG,cAAc,MAAM;EAAG,GAAG;CAAQ,CAAC;AACjE"}

package/dist/factory.cjs

@@ -1,29 +1,89 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_response = require("./response-hnSw2NKE.cjs");
-const require_factory = require("./factory-DG1CVkEb.cjs");
-exports.createArrowFunction = require_response.createArrowFunction;
-exports.createBreak = require_response.createBreak;
-exports.createConst = require_response.createConst;
-exports.createContent = require_response.createContent;
-exports.createExport = require_response.createExport;
-exports.createFile = require_factory.createFile;
-exports.createFunction = require_response.createFunction;
-exports.createFunctionParameter = require_response.createFunctionParameter;
-exports.createFunctionParameters = require_response.createFunctionParameters;
-exports.createImport = require_response.createImport;
-exports.createIndexedAccessType = require_response.createIndexedAccessType;
-exports.createInput = require_response.createInput;
-exports.createJsx = require_response.createJsx;
-exports.createObjectBindingPattern = require_response.createObjectBindingPattern;
-exports.createOperation = require_response.createOperation;
-exports.createOutput = require_response.createOutput;
-exports.createParameter = require_response.createParameter;
-exports.createProperty = require_response.createProperty;
-exports.createRequestBody = require_response.createRequestBody;
-exports.createResponse = require_response.createResponse;
-exports.createSchema = require_response.createSchema;
-exports.createSource = require_response.createSource;
-exports.createText = require_response.createText;
-exports.createType = require_response.createType;
-exports.createTypeLiteral = require_response.createTypeLiteral;
-exports.update = require_factory.update;
+const require_schema = require("./schema-BkvrrOAr.cjs");
+//#region src/factory.ts
+var factory_exports = /* @__PURE__ */ require_schema.__exportAll({
+	createArrowFunction: () => require_schema.createArrowFunction,
+	createBreak: () => require_schema.createBreak,
+	createConst: () => require_schema.createConst,
+	createContent: () => require_schema.createContent,
+	createExport: () => require_schema.createExport,
+	createFile: () => require_schema.createFile,
+	createFunction: () => require_schema.createFunction,
+	createFunctionParameter: () => require_schema.createFunctionParameter,
+	createFunctionParameters: () => require_schema.createFunctionParameters,
+	createImport: () => require_schema.createImport,
+	createIndexedAccessType: () => require_schema.createIndexedAccessType,
+	createInput: () => require_schema.createInput,
+	createJsx: () => require_schema.createJsx,
+	createObjectBindingPattern: () => require_schema.createObjectBindingPattern,
+	createOperation: () => require_schema.createOperation,
+	createOutput: () => require_schema.createOutput,
+	createParameter: () => require_schema.createParameter,
+	createProperty: () => require_schema.createProperty,
+	createRequestBody: () => require_schema.createRequestBody,
+	createResponse: () => require_schema.createResponse,
+	createSchema: () => require_schema.createSchema,
+	createSource: () => require_schema.createSource,
+	createText: () => require_schema.createText,
+	createType: () => require_schema.createType,
+	createTypeLiteral: () => require_schema.createTypeLiteral,
+	update: () => update
+});
+/**
+* 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 does not allocate and
+* downstream passes can detect "nothing changed" by identity. Comparison is shallow,
+* so a structurally equal but newly allocated array or 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;
+}
+//#endregion
+exports.createArrowFunction = require_schema.createArrowFunction;
+exports.createBreak = require_schema.createBreak;
+exports.createConst = require_schema.createConst;
+exports.createContent = require_schema.createContent;
+exports.createExport = require_schema.createExport;
+exports.createFile = require_schema.createFile;
+exports.createFunction = require_schema.createFunction;
+exports.createFunctionParameter = require_schema.createFunctionParameter;
+exports.createFunctionParameters = require_schema.createFunctionParameters;
+exports.createImport = require_schema.createImport;
+exports.createIndexedAccessType = require_schema.createIndexedAccessType;
+exports.createInput = require_schema.createInput;
+exports.createJsx = require_schema.createJsx;
+exports.createObjectBindingPattern = require_schema.createObjectBindingPattern;
+exports.createOperation = require_schema.createOperation;
+exports.createOutput = require_schema.createOutput;
+exports.createParameter = require_schema.createParameter;
+exports.createProperty = require_schema.createProperty;
+exports.createRequestBody = require_schema.createRequestBody;
+exports.createResponse = require_schema.createResponse;
+exports.createSchema = require_schema.createSchema;
+exports.createSource = require_schema.createSource;
+exports.createText = require_schema.createText;
+exports.createType = require_schema.createType;
+exports.createTypeLiteral = require_schema.createTypeLiteral;
+Object.defineProperty(exports, "factory_exports", {
+	enumerable: true,
+	get: function() {
+		return factory_exports;
+	}
+});
+exports.update = update;
+
+//# sourceMappingURL=factory.cjs.map

package/dist/factory.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.cjs","names":[],"sources":["../src/factory.ts"],"sourcesContent":["import type { Node } from './nodes/index.ts'\n\n// Node constructors, grouped under the `factory` namespace the way the TypeScript compiler exposes\n// `ts.factory.createX`. Aggregating them here lets `export * as factory from './factory.ts'` in the\n// barrel surface every `createX` alongside the `createFile`/`update` helpers from a single module.\nexport { createArrowFunction, createBreak, createConst, createFunction, createJsx, createText, createType } from './nodes/code.ts'\nexport { createContent } from './nodes/content.ts'\nexport { createExport, createFile, createImport, createSource } from './nodes/file.ts'\nexport type { UserFileNode } from './nodes/file.ts'\nexport { createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createTypeLiteral } from './nodes/function.ts'\nexport { createInput } from './nodes/input.ts'\nexport { createOperation } from './nodes/operation.ts'\nexport { createOutput } from './nodes/output.ts'\nexport { createParameter } from './nodes/parameter.ts'\nexport { createProperty } from './nodes/property.ts'\nexport { createRequestBody } from './nodes/requestBody.ts'\nexport { createResponse } from './nodes/response.ts'\nexport { createSchema } from './nodes/schema.ts'\n\n/**\n * Identity-preserving node update: returns `node` unchanged when every field in\n * `changes` already equals (by reference) the current value, otherwise a new node\n * with the changes applied.\n *\n * Mirrors the TypeScript compiler's `factory.updateX` contract. Pair it with the\n * structural sharing in {@link transform} so a no-op rewrite does not allocate and\n * downstream passes can detect \"nothing changed\" by identity. Comparison is shallow,\n * so a structurally equal but newly allocated array or object counts as a change.\n *\n * @example\n * ```ts\n * update(node, { name: node.name })        // -> same `node` reference\n * update(node, { name: 'renamed' })        // -> new node, `name` replaced\n * ```\n */\nexport function update<T extends Node>(node: T, changes: Partial<T>): T {\n  for (const key in changes) {\n    if (changes[key] !== node[key as keyof T]) {\n      return { ...node, ...changes }\n    }\n  }\n\n  return node\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,OAAuB,MAAS,SAAwB;CACtE,KAAK,MAAM,OAAO,SAChB,IAAI,QAAQ,SAAS,KAAK,MACxB,OAAO;EAAE,GAAG;EAAM,GAAG;CAAQ;CAIjC,OAAO;AACT"}

package/dist/factory.d.ts

@@ -1,5 +1,5 @@
 import { n as __name, t as __exportAll } from "./chunk-CNktS9qV.js";
-import { F as createFunctionParameter, Gt as createBreak, I as createFunctionParameters, Jt as createJsx, K as FileNode, Kt as createConst, L as createIndexedAccessType, Ot as createProperty, R as createObjectBindingPattern, T as createParameter, Wt as createArrowFunction, X as createImport, Xt as createType, Y as createExport, Yt as createText, Z as createSource, at as createContent, g as createResponse, p as createOperation, qt as createFunction, r as createOutput, s as createInput, t as Node, wt as createSchema, x as createRequestBody, z as createTypeLiteral } from "./index-BzjwdK2M.js";
+import { F as createFunctionParameters, Gt as createBreak, I as createIndexedAccessType, J as UserFileNode, Jt as createJsx, Kt as createConst, L as createObjectBindingPattern, Ot as createProperty, P as createFunctionParameter, Q as createSource, R as createTypeLiteral, Wt as createArrowFunction, X as createFile, Xt as createType, Y as createExport, Yt as createText, Z as createImport, _ as createResponse, at as createContent, b as createRequestBody, p as createOperation, qt as createFunction, r as createOutput, s as createInput, t as Node, w as createParameter, wt as createSchema } from "./index-B9cc8MBS.js";
 
 //#region src/factory.d.ts
 declare namespace factory_d_exports {
@@ -10,10 +10,10 @@ declare namespace factory_d_exports {
  * `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.
+ * Mirrors the TypeScript compiler's `factory.updateX` contract. Pair it with the
+ * structural sharing in {@link transform} so a no-op rewrite does not allocate and
+ * downstream passes can detect "nothing changed" by identity. Comparison is shallow,
+ * so a structurally equal but newly allocated array or object counts as a change.
  *
  * @example
  * ```ts
@@ -22,41 +22,6 @@ declare namespace factory_d_exports {
  * ```
  */
 declare function update<T extends Node>(node: T, changes: Partial<T>): T;
-/**
- * Input descriptor for {@link createFile}, before `id`, `name`, and `extname` are computed
- * and `imports`/`exports`/`sources` are deduplicated.
- */
-type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind' | 'id' | 'name' | 'extname' | 'imports' | 'exports' | 'sources'> & Pick<Partial<FileNode<TMeta>>, 'imports' | 'exports' | 'sources'>;
-/**
- * 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'
- * ```
- */
-declare function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta>;
 //#endregion
-export { UserFileNode, createArrowFunction, createBreak, createConst, createContent, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createIndexedAccessType, createInput, createJsx, createObjectBindingPattern, createOperation, createOutput, createParameter, createProperty, createRequestBody, createResponse, createSchema, createSource, createText, createType, createTypeLiteral, factory_d_exports as t, update };
+export { type UserFileNode, createArrowFunction, createBreak, createConst, createContent, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createIndexedAccessType, createInput, createJsx, createObjectBindingPattern, createOperation, createOutput, createParameter, createProperty, createRequestBody, createResponse, createSchema, createSource, createText, createType, createTypeLiteral, factory_d_exports as t, update };
 //# sourceMappingURL=factory.d.ts.map

package/dist/factory.js

@@ -1,3 +1,58 @@
-import { B as createFunction, D as createSource, E as createImport, H as createText, L as createArrowFunction, N as createContent, R as createBreak, T as createExport, U as createType, V as createJsx, X as createSchema, _ as createIndexedAccessType, a as createParameter, d as createRequestBody, g as createFunctionParameters, h as createFunctionParameter, l as createOperation, p as createInput, r as createProperty, s as createOutput, t as createResponse, v as createObjectBindingPattern, y as createTypeLiteral, z as createConst } from "./response-KUdWiDWw.js";
-import { r as update, t as createFile } from "./factory-CZNOGI-N.js";
-export { createArrowFunction, createBreak, createConst, createContent, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createIndexedAccessType, createInput, createJsx, createObjectBindingPattern, createOperation, createOutput, createParameter, createProperty, createRequestBody, createResponse, createSchema, createSource, createText, createType, createTypeLiteral, update };
+import { t as __exportAll } from "./chunk-CNktS9qV.js";
+import { A as createImport, B as createContent, G as createBreak, J as createJsx, K as createConst, O as createExport, S as createTypeLiteral, W as createArrowFunction, X as createType, Y as createText, a as createProperty, b as createIndexedAccessType, f as createOperation, g as createInput, j as createSource, k as createFile, m as createRequestBody, q as createFunction, r as createResponse, s as createParameter, t as createSchema, u as createOutput, v as createFunctionParameter, x as createObjectBindingPattern, y as createFunctionParameters } from "./schema-Cbnxmz4b.js";
+//#region src/factory.ts
+var factory_exports = /* @__PURE__ */ __exportAll({
+	createArrowFunction: () => createArrowFunction,
+	createBreak: () => createBreak,
+	createConst: () => createConst,
+	createContent: () => createContent,
+	createExport: () => createExport,
+	createFile: () => createFile,
+	createFunction: () => createFunction,
+	createFunctionParameter: () => createFunctionParameter,
+	createFunctionParameters: () => createFunctionParameters,
+	createImport: () => createImport,
+	createIndexedAccessType: () => createIndexedAccessType,
+	createInput: () => createInput,
+	createJsx: () => createJsx,
+	createObjectBindingPattern: () => createObjectBindingPattern,
+	createOperation: () => createOperation,
+	createOutput: () => createOutput,
+	createParameter: () => createParameter,
+	createProperty: () => createProperty,
+	createRequestBody: () => createRequestBody,
+	createResponse: () => createResponse,
+	createSchema: () => createSchema,
+	createSource: () => createSource,
+	createText: () => createText,
+	createType: () => createType,
+	createTypeLiteral: () => createTypeLiteral,
+	update: () => update
+});
+/**
+* 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 does not allocate and
+* downstream passes can detect "nothing changed" by identity. Comparison is shallow,
+* so a structurally equal but newly allocated array or 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;
+}
+//#endregion
+export { createArrowFunction, createBreak, createConst, createContent, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createIndexedAccessType, createInput, createJsx, createObjectBindingPattern, createOperation, createOutput, createParameter, createProperty, createRequestBody, createResponse, createSchema, createSource, createText, createType, createTypeLiteral, factory_exports as t, update };
+
+//# sourceMappingURL=factory.js.map

package/dist/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","names":[],"sources":["../src/factory.ts"],"sourcesContent":["import type { Node } from './nodes/index.ts'\n\n// Node constructors, grouped under the `factory` namespace the way the TypeScript compiler exposes\n// `ts.factory.createX`. Aggregating them here lets `export * as factory from './factory.ts'` in the\n// barrel surface every `createX` alongside the `createFile`/`update` helpers from a single module.\nexport { createArrowFunction, createBreak, createConst, createFunction, createJsx, createText, createType } from './nodes/code.ts'\nexport { createContent } from './nodes/content.ts'\nexport { createExport, createFile, createImport, createSource } from './nodes/file.ts'\nexport type { UserFileNode } from './nodes/file.ts'\nexport { createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createTypeLiteral } from './nodes/function.ts'\nexport { createInput } from './nodes/input.ts'\nexport { createOperation } from './nodes/operation.ts'\nexport { createOutput } from './nodes/output.ts'\nexport { createParameter } from './nodes/parameter.ts'\nexport { createProperty } from './nodes/property.ts'\nexport { createRequestBody } from './nodes/requestBody.ts'\nexport { createResponse } from './nodes/response.ts'\nexport { createSchema } from './nodes/schema.ts'\n\n/**\n * Identity-preserving node update: returns `node` unchanged when every field in\n * `changes` already equals (by reference) the current value, otherwise a new node\n * with the changes applied.\n *\n * Mirrors the TypeScript compiler's `factory.updateX` contract. Pair it with the\n * structural sharing in {@link transform} so a no-op rewrite does not allocate and\n * downstream passes can detect \"nothing changed\" by identity. Comparison is shallow,\n * so a structurally equal but newly allocated array or object counts as a change.\n *\n * @example\n * ```ts\n * update(node, { name: node.name })        // -> same `node` reference\n * update(node, { name: 'renamed' })        // -> new node, `name` replaced\n * ```\n */\nexport function update<T extends Node>(node: T, changes: Partial<T>): T {\n  for (const key in changes) {\n    if (changes[key] !== node[key as keyof T]) {\n      return { ...node, ...changes }\n    }\n  }\n\n  return node\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,OAAuB,MAAS,SAAwB;CACtE,KAAK,MAAM,OAAO,SAChB,IAAI,QAAQ,SAAS,KAAK,MACxB,OAAO;EAAE,GAAG;EAAM,GAAG;CAAQ;CAIjC,OAAO;AACT"}