@keq-request/cli 5.0.0-alpha.27 → 5.0.0-alpha.29

package/dist/cli.js

@@ -28,9 +28,8 @@ import { Listr } from "listr2";
 import { AsyncParallelHook, AsyncSeriesBailHook, AsyncSeriesHook, SyncHook } from "tapable";
 
 // src/compiler/tasks/setup/index.ts
-import fs3 from "fs-extra";
-import path2 from "path";
-import { Value } from "@sinclair/typebox/value";
+import fs4 from "fs-extra";
+import path10 from "path";
 import { cosmiconfig } from "cosmiconfig";
 
 // src/utils/ignore-matcher.ts
@@ -124,8 +123,51 @@ var IgnoreMatcher = class _IgnoreMatcher {
   }
 };
 
-// src/types/runtime-config.ts
+// src/compiler/tasks/setup/utils/find-nearest-package-json.ts
+import fs2 from "fs";
+import path from "path";
+function findNearestPackageJson(startDir = process.cwd()) {
+  let dir = startDir;
+  while (true) {
+    const pkgPath = path.join(dir, "package.json");
+    if (fs2.existsSync(pkgPath)) {
+      const json = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+      return { json, path: pkgPath };
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// src/compiler/tasks/setup/utils/get-project-module-system.ts
+function getProjectModuleSystem(pkgInfo) {
+  if (!pkgInfo?.json) return "cjs";
+  const { json } = pkgInfo;
+  if (json.type === "module") return "esm";
+  return "cjs";
+}
+
+// src/compiler/tasks/setup/utils/parse-runtime-config.ts
+import { Value } from "@sinclair/typebox/value";
+
+// src/types/address.ts
 import { Type } from "@sinclair/typebox";
+var Address = Type.Object({
+  url: Type.String(),
+  headers: Type.Optional(Type.Record(Type.String(), Type.String(), { default: {} })),
+  encoding: Type.Optional(
+    Type.Union([
+      Type.Literal("utf8"),
+      Type.Literal("ascii")
+    ], { default: "utf8" })
+  )
+});
+
+// src/types/runtime-config.ts
+import * as R2 from "ramda";
+import { Type as Type2 } from "@sinclair/typebox";
 
 // src/constants/file-naming-style.ts
 var FileNamingStyle = /* @__PURE__ */ ((FileNamingStyle2) => {
@@ -143,168 +185,173 @@ var FileNamingStyle = /* @__PURE__ */ ((FileNamingStyle2) => {
   return FileNamingStyle2;
 })(FileNamingStyle || {});
 
+// src/utils/is-valid-url.ts
+var URL_REGEX = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/(?:[^\s@]+@)?[^\s/:?#]*(?::\d+)?(?:\/[^\s?#]*)?(?:\?[^\s#]*)?(?:#[^\s]*)?$/;
+function isValidURL(url) {
+  return URL_REGEX.test(url);
+}
+
 // src/types/runtime-config.ts
-var RuntimeConfig = Type.Object({
-  mode: Type.Optional(
-    Type.Union([
-      Type.Literal("micro-function"),
-      Type.Literal("nestjs-module"),
-      Type.Literal("none")
-    ], { default: "micro-function" })
-  ),
+var Modules = Type2.Transform(
+  Type2.Record(
+    Type2.String(),
+    Type2.Union([Type2.String(), Address])
+  )
+).Decode((value) => {
+  const keys2 = Object.keys(value);
+  for (const key of keys2) {
+    if (!/^[A-Za-z_][A-Za-z0-9_$]*$/.test(key)) {
+      throw new Error(`Module name "${key}" is not valid. It must start with a letter or underscore, and can only contain letters, numbers, and underscores.`);
+    }
+  }
+  const keysGroupByLowerCase = R2.groupBy(R2.toLower, keys2);
+  for (const groupKey in keysGroupByLowerCase) {
+    const keys3 = keysGroupByLowerCase[groupKey] || [];
+    if (keys3.length > 1) {
+      throw new Error(`Module names ${keys3.map((name) => `"${name}"`).join(", ")} are case-insensitively duplicated.`);
+    }
+  }
+  for (const key in value) {
+    const url = typeof value[key] === "string" ? value[key] : value[key].url;
+    if (isValidURL(url)) continue;
+    throw new Error(`The ${JSON.stringify(url)} of module "${key}" is not a valid URL.`);
+  }
+  return R2.map(
+    (item) => typeof item !== "string" ? item : { url: item, headers: {}, encoding: "utf8" },
+    value
+  );
+}).Encode((value) => value);
+var RawConfig = Type2.Object({
   /**
    * Whether to generate ES Module code
    *
    * If not specified, the module system will be inferred from the nearest package.json "type" field
    * or defaults to "cjs" if no package.json is found.
    */
-  esm: Type.Optional(Type.Boolean({ default: false })),
+  esm: Type2.Optional(Type2.Boolean({ default: false })),
   /**
    * Output directory for generated files
    */
-  outdir: Type.String({ default: `${process.cwd()}/api` }),
+  outdir: Type2.String({ default: `${process.cwd()}/api` }),
   /**
    * File naming style for generated files
    */
-  fileNamingStyle: Type.Enum(FileNamingStyle, { default: "snakeCase" /* snakeCase */ }),
-  modules: Type.Record(Type.String(), Type.String()),
-  debug: Type.Optional(Type.Boolean({ default: false })),
+  fileNamingStyle: Type2.Enum(FileNamingStyle, { default: "snakeCase" /* snakeCase */ }),
+  /**
+   * OpenAPI/Swagger document sources
+   *
+   * A map of module names to their document URLs or Address objects.
+   * The module name must be a valid JavaScript identifier.
+   */
+  modules: Modules,
+  /**
+   * Enable debug mode to output detailed logs during compilation
+   */
+  debug: Type2.Optional(Type2.Boolean({ default: false })),
   /**
    * Whether to tolerate wrong openapi/swagger structure
    */
-  tolerant: Type.Optional(Type.Boolean({ default: false })),
-  plugins: Type.Optional(Type.Array(Type.Any(), { default: [] }))
+  tolerant: Type2.Optional(Type2.Boolean({ default: false })),
+  /**
+   * Translators to transform generated code
+   *
+   * Used to customize the code generation process for different frameworks or patterns.
+   * Can be a single translator or an array of translators.
+   */
+  translators: Type2.Optional(
+    Type2.Transform(
+      Type2.Union([
+        Type2.Unsafe(Type2.Any()),
+        Type2.Array(Type2.Unsafe(Type2.Any()))
+      ], { default: [] })
+    ).Decode((value) => {
+      if (value === void 0) return [];
+      if (Array.isArray(value)) return value;
+      return [value];
+    }).Encode((value) => value)
+  ),
+  /**
+   * Plugins to extend code generation functionality
+   *
+   * An array of plugin instances that can hook into various stages of the compilation process,
+   * such as code transformation, formatting, linting, or custom file generation.
+   */
+  plugins: Type2.Optional(Type2.Array(Type2.Unsafe(Type2.Any()), { default: [] }))
 });
 
-// src/compiler/tasks/setup/utils/validate-modules.ts
-import * as R2 from "ramda";
-import validator from "validator";
-function validateModules(modules) {
-  const keys2 = Object.keys(modules);
-  for (const key of keys2) {
-    if (!/^[A-Za-z_][A-Za-z0-9_$]*$/.test(key)) {
-      throw new Error(`Module name "${key}" is not valid. It must start with a letter or underscore, and can only contain letters, numbers, and underscores.`);
-    }
-  }
-  const keysGroupByLowerCase = R2.groupBy(R2.toLower, keys2);
-  for (const groupKey in keysGroupByLowerCase) {
-    const keys3 = keysGroupByLowerCase[groupKey] || [];
-    if (keys3.length > 1) {
-      throw new Error(`Module names ${keys3.map((name) => `"${name}"`).join(", ")} are case-insensitively duplicated.`);
+// src/compiler/tasks/setup/utils/parse-runtime-config.ts
+function parseRuntimeConfig(data) {
+  try {
+    const originalPlugins = typeof data === "object" && data !== null && "plugins" in data ? data.plugins : void 0;
+    const originTranslators = typeof data === "object" && data !== null && "translators" in data ? data.translators : void 0;
+    const parsed = Value.Parse(RawConfig, data);
+    if (originalPlugins !== void 0) {
+      parsed.plugins = originalPlugins;
     }
-  }
-  for (const key in modules) {
-    const address = modules[key];
-    if (validator.isURL(address, { require_host: true, require_protocol: true, protocols: ["http", "https"] })) {
-      continue;
+    if (originTranslators !== void 0) {
+      parsed.translators = originTranslators;
     }
-    if (/^(\/|\.\/|\.\.\/)/.test(address)) {
-      continue;
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error) {
+      error.message = `Invalid Config: ${error.message}`;
     }
-    throw new Error(`Module address "${address}" of module "${key}" is not valid. It must be a URL or a local path.`);
+    throw error;
   }
 }
 
-// src/compiler/tasks/setup/utils/find-nearest-package-json.ts
-import fs2 from "fs";
-import path from "path";
-function findNearestPackageJson(startDir = process.cwd()) {
-  let dir = startDir;
-  while (true) {
-    const pkgPath = path.join(dir, "package.json");
-    if (fs2.existsSync(pkgPath)) {
-      const json = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
-      return { json, path: pkgPath };
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
+// src/plugins/eslint/eslint.plugin.ts
+import { ESLint } from "eslint";
+
+// src/plugins/prettier/prettier.plugin.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+
+// src/plugins/body-fallback/index.ts
+import * as R21 from "ramda";
+
+// src/utils/json-schema-utils/is-array.ts
+function isArray(schema) {
+  return schema.type === "array";
 }
 
-// src/compiler/tasks/setup/utils/get-project-module-system.ts
-function getProjectModuleSystem(pkgInfo) {
-  if (!pkgInfo?.json) return "cjs";
-  const { json } = pkgInfo;
-  if (json.type === "module") return "esm";
-  return "cjs";
+// src/utils/json-schema-utils/is-mixed.ts
+function isMixed(schema) {
+  return Array.isArray(schema.type);
 }
 
-// src/compiler/tasks/setup/index.ts
-var explore = cosmiconfig("keq");
-function main(compiler, options) {
-  return {
-    task: async (context, task) => {
-      const result = options?.config ? await explore.load(options.config) : await explore.search();
-      if (!result || "isEmpty" in result && result.isEmpty) {
-        throw new Error("Cannot find config file.");
-      }
-      if (!Value.Check(RuntimeConfig, result.config)) {
-        const errors = [...Value.Errors(RuntimeConfig, result.config)];
-        const message = errors.map(({ path: path13, message: message2 }) => `${path13}: ${message2}`).join("\n");
-        throw new Error(`Invalid Config: ${message}`);
-      }
-      const rc = Value.Default(RuntimeConfig, result.config);
-      validateModules(rc.modules);
-      if (options?.debug) {
-        await fs3.ensureDir(".keq");
-        rc.debug = true;
-      }
-      rc.tolerant = Boolean(rc.tolerant);
-      const packageJsonInfo = findNearestPackageJson();
-      if (packageJsonInfo) {
-        const moduleSystem = getProjectModuleSystem(packageJsonInfo);
-        rc.esm = moduleSystem === "esm";
-      }
-      context.rc = rc;
-      let matcher = new IgnoreMatcher([]);
-      if (result.filepath) {
-        const ignoreFilepath = path2.resolve(path2.dirname(result.filepath), ".keqignore");
-        if (await fs3.exists(ignoreFilepath)) {
-          matcher = await IgnoreMatcher.read(ignoreFilepath);
-        }
-      }
-      const ignoreRules = options.ignore === false ? [] : options.ignore?.rules || [];
-      for (const rule of ignoreRules) {
-        matcher.append({
-          persist: !!rule.persist,
-          ignore: rule.ignore,
-          moduleName: rule.moduleName,
-          operationMethod: rule.operationMethod,
-          operationPathname: rule.operationPathname
-        });
-      }
-      context.matcher = matcher;
-      await compiler.hooks.setup.promise(task);
-    }
-  };
+// src/utils/json-schema-utils/is-non-array.ts
+function isNonArray(schema) {
+  return typeof schema.type === "string" && schema.type !== "array";
 }
-function createSetupTask(compiler, options) {
-  return {
-    title: "Setup",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (context, task) => task.newListr(
-      [
-        main(compiler, options),
-        {
-          task: (context2, task2) => compiler.hooks.afterSetup.promise(task2)
-        }
-      ],
-      {
-        concurrent: false
-      }
-    )
-  };
+
+// src/utils/json-schema-utils/is-ref.ts
+function isRef(schema) {
+  return "$ref" in schema;
 }
 
-// src/compiler/tasks/download/index.ts
-import { PRESET_TIMER } from "listr2";
-import { validate } from "@scalar/openapi-parser";
+// src/utils/json-schema-utils/index.ts
+var JsonSchemaUtils = class {
+  static isRef = isRef;
+  static isArray = isArray;
+  static isNonArray = isNonArray;
+  static isMixed = isMixed;
+};
+
+// src/plugins/generate-micro-function/generate-micro-function.plugin.ts
+import { AsyncSeriesWaterfallHook as AsyncSeriesWaterfallHook2 } from "tapable";
+
+// src/plugins/generate-micro-function/constants/metadata-storage.ts
+var MetadataStorage3 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/generate-micro-function/generators/micro_function/micro-function.generator.ts
+import * as R20 from "ramda";
+import * as path8 from "path";
+import * as changeCase6 from "change-case";
 
 // src/models/artifact.ts
-import * as path3 from "path";
+import * as path2 from "path";
 
 // src/models/anchor.ts
 var AnchorBlock = class {
@@ -390,11 +437,11 @@ var Artifact = class {
   constructor(options) {
     this.id = options.id;
     this.filepath = options.filepath;
-    this.extensionName = options.extensionName || path3.extname(options.filepath);
+    this.extensionName = options.extensionName || path2.extname(options.filepath);
     this.content = options.content;
   }
   get dirname() {
-    return path3.dirname(this.filepath);
+    return path2.dirname(this.filepath);
   }
   renderer() {
     return `${HeaderComment}${this.content}`;
@@ -410,10 +457,14 @@ var ModuleDefinition = class _ModuleDefinition {
   address;
   constructor(name, address) {
     this.name = name;
-    this.address = address;
+    if (typeof address === "string") {
+      this.address = { url: address, headers: {}, encoding: "utf8" };
+    } else {
+      this.address = address;
+    }
   }
   static unknown() {
-    return new _ModuleDefinition("", "");
+    return new _ModuleDefinition("", { url: "", headers: {}, encoding: "utf8" });
   }
 };
 
@@ -625,8 +676,8 @@ var ApiDocumentV3_1 = class _ApiDocumentV3_1 {
   }
   isRefDefined($ref) {
     if ($ref.startsWith("#/")) {
-      const path13 = $ref.replace("#/", "").split("/");
-      return R5.path(path13, this.specification) !== void 0;
+      const path12 = $ref.replace("#/", "").split("/");
+      return R5.path(path12, this.specification) !== void 0;
     }
     return false;
   }
@@ -638,61 +689,296 @@ var ApiDocumentV3_1 = class _ApiDocumentV3_1 {
 // src/models/asset.ts
 var Asset = class {
   path;
-  constructor(path13) {
-    this.path = path13;
+  constructor(path12) {
+    this.path = path12;
   }
 };
 
-// src/exception.ts
-import { CustomError } from "ts-custom-error";
-import wrap from "word-wrap";
-var Exception = class extends CustomError {
-  constructor(module, message) {
-    const moduleName = typeof module === "string" ? module : module.name;
-    const msg = wrap(message, { width: 60, indent: "    " });
-    super(`${moduleName} module failed to compile:
-${msg}`);
-    Object.defineProperty(this, "name", { value: "KeqCLI_Exception" });
-  }
-};
+// src/plugins/generate-declaration/generate-declaration.plugin.ts
+import { AsyncSeriesWaterfallHook } from "tapable";
 
-// src/utils/openapi-utils/dereference.ts
-function dereference($ref, swagger) {
-  let value;
-  for (const key of $ref.split("/")) {
-    if (key === "#") {
-      value = swagger;
-    } else {
-      value = value[key];
+// src/plugins/generate-declaration/generators/operation-declaration/operation.generator.ts
+import * as path7 from "path";
+import * as changeCase5 from "change-case";
+
+// src/transformers/json-schema/comment.renderer.ts
+var CommentRenderer = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  render() {
+    const schema = this.schema;
+    const lines = ["/**"];
+    if (schema.description) {
+      const description = schema.description.replace("*/", "*\\/");
+      lines.push(...description.split("\n").map((line) => ` * ${line}`));
     }
-    if (!value) break;
+    if (schema.deprecated) {
+      lines.push(" * @deprecated");
+    }
+    if (schema.readOnly) {
+      lines.push(" * @readonly");
+    }
+    if (schema.format) {
+      lines.push(` * @format ${schema.format}`);
+    }
+    lines.push(" */");
+    if (lines.length === 2) return "";
+    return lines.join("\n");
   }
-  return value;
-}
+};
 
-// src/utils/openapi-utils/dereference-operation.ts
+// src/transformers/json-schema/declaration.renderer.ts
+import * as R7 from "ramda";
+
+// src/utils/indent.ts
+function indent(space, text) {
+  if (text === "") return "";
+  const indentation = " ".repeat(space);
+  return text.split("\n").map((line) => line ? `${indentation}${line}` : line).join("\n");
+}
+
+// src/transformers/json-schema/reference.transformer.ts
+import * as R6 from "ramda";
+var ReferenceTransformer = class {
+  static toDeclaration(schema, alias2 = R6.identity) {
+    if (!schema.$ref || !schema.$ref.startsWith("#")) return `unknown /* ${schema.$ref.replace("*/", "*\\/")} */`;
+    const parts = schema.$ref.split("/");
+    return alias2(parts[parts.length - 1]) || "unknown";
+  }
+};
+
+// src/transformers/json-schema/declaration.renderer.ts
+var DeclarationRenderer = class {
+  constructor(schema, options = {}) {
+    this.schema = schema;
+    this.options = options;
+  }
+  render() {
+    return this.renderSchema(this.schema);
+  }
+  renderSchema(schema) {
+    if (typeof schema === "boolean") return "unknown";
+    if (JsonSchemaUtils.isRef(schema)) return this.renderReference(schema);
+    if (JsonSchemaUtils.isMixed(schema)) return this.renderMixed(schema);
+    if (JsonSchemaUtils.isArray(schema)) return this.renderArray(schema);
+    if (schema.type === "object") return this.renderObject(schema);
+    if (schema.enum) return this.renderEnum(schema);
+    if (schema.oneOf) return this.renderOneOf(schema);
+    if (schema.anyOf) return this.renderAnyOf(schema);
+    if (schema.allOf) return this.renderAllOf(schema);
+    if (schema.type === "string") return this.renderString(schema);
+    if (schema.type === "number") return this.renderNumber(schema);
+    if (schema.type === "boolean") return this.renderBoolean(schema);
+    if (schema.type === "null") return this.renderNull(schema);
+    if (schema.type === "integer") return this.renderInteger(schema);
+    return "unknown";
+  }
+  renderMixed(schema) {
+    if (Array.isArray(schema.type)) {
+      schema.type.map((type) => ({ ...schema, type })).map((schema2) => this.renderSchema(schema2)).join(" | ");
+    }
+    return "unknown";
+  }
+  renderReference(schema) {
+    if (!this.options.referenceTransformer) {
+      return ReferenceTransformer.toDeclaration(schema);
+    }
+    return this.options.referenceTransformer(schema);
+  }
+  renderArray(schema) {
+    if (schema.items && Array.isArray(schema.items)) {
+      const items = schema.items.map((s) => this.renderSchema(s)).join(", ");
+      return `[${items}]`;
+    }
+    if (schema.items && typeof schema.items === "object") {
+      return `${this.renderSchema(schema.items)}[]`;
+    }
+    return "any[]";
+  }
+  renderObject(schema) {
+    if ((!schema.properties || R7.isEmpty(schema.properties)) && (!schema.additionalProperties || R7.isEmpty(schema.additionalProperties))) {
+      return "object";
+    }
+    const $properties = Object.entries(schema.properties || {}).map(([propertyName, propertySchema]) => {
+      let $comment = new CommentRenderer(propertySchema).render();
+      if ($comment) $comment += "\n";
+      const $key = `"${propertyName}"${schema.required?.includes(propertyName) ? "" : "?"}`;
+      const $value = this.renderSchema(propertySchema);
+      return indent(2, `${$comment}${$key}: ${$value}`);
+    });
+    if (schema.additionalProperties) {
+      const $value = schema.additionalProperties === true ? "any" : this.renderSchema(schema.additionalProperties);
+      $properties.push(indent(2, `[key: string]: ${$value}`));
+    }
+    return [
+      "{",
+      ...$properties,
+      "}"
+    ].join("\n");
+  }
+  renderOneOf(schema) {
+    if (!schema.oneOf) return "unknown";
+    return schema.oneOf.map((s) => this.renderSchema(s)).join(" | ");
+  }
+  renderAnyOf(schema) {
+    if (!schema.anyOf) return "unknown";
+    return schema.anyOf.map((s) => this.renderSchema(s)).join(" | ");
+  }
+  renderAllOf(schema) {
+    if (!schema.allOf) return "unknown";
+    return schema.allOf.map((s) => this.renderSchema(s)).join(" & ");
+  }
+  renderEnum(schema) {
+    if (!schema.enum) return "unknown";
+    return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+  }
+  renderString(schema) {
+    if (schema.contentMediaType === "application/octet-stream") return "Blob | Buffer";
+    if (schema.format === "binary") return "Blob | Buffer";
+    return "string";
+  }
+  renderNumber(schema) {
+    return "number";
+  }
+  renderBoolean(schema) {
+    return "boolean";
+  }
+  renderNull(schema) {
+    return "null";
+  }
+  renderInteger(schema) {
+    return "number";
+  }
+};
+
+// src/transformers/json-schema/json-schema.transformer.ts
+var JsonSchemaTransformer = class {
+  static toComment(schema) {
+    return new CommentRenderer(schema).render();
+  }
+  static toDeclaration(schema, options) {
+    return new DeclarationRenderer(schema, options).render();
+  }
+};
+
+// src/transformers/schema-definition/schema-definition.transformer.ts
 import * as R8 from "ramda";
+var SchemaDefinitionTransformer = class {
+  static toDeclaration(schemaDefinition, options) {
+    const dependencies = schemaDefinition.getDependencies();
+    let $dependencies = dependencies.filter((dep) => !SchemaDefinition.isUnknown(dep)).map((dep) => {
+      const filepath = options.getDependentSchemaDefinitionFilepath(dep);
+      return `import type { ${dep.name} } from "${filepath}"`;
+    }).map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, options.esm ? ' from "$1.js"' : ' from "$1"')).join("\n");
+    if ($dependencies) $dependencies += "\n";
+    let $comment = JsonSchemaTransformer.toComment(schemaDefinition.schema);
+    if ($comment) $comment += "\n";
+    if (typeof schemaDefinition.schema === "boolean") {
+      return [
+        "/* @anchor:file:start */",
+        "",
+        $dependencies,
+        $comment || void 0,
+        `type ${schemaDefinition.name} = unknown`,
+        "",
+        "/* @anchor:file:end */"
+      ].filter(R8.isNotNil).join("\n");
+    }
+    if (JsonSchemaUtils.isNonArray(schemaDefinition.schema) && schemaDefinition.schema.type === "object") {
+      const $schema = JsonSchemaTransformer.toDeclaration(schemaDefinition.schema);
+      const $declaration = $schema.startsWith("{") ? `export interface ${schemaDefinition.name} ${$schema}` : `export type ${schemaDefinition.name} = ${$schema}`;
+      return [
+        "/* @anchor:file:start */",
+        "",
+        $dependencies,
+        $comment || void 0,
+        $declaration,
+        "",
+        "/* @anchor:file:end */"
+      ].filter(R8.isNotNil).join("\n");
+    }
+    return [
+      "/* @anchor:file:start */",
+      "",
+      $dependencies,
+      $comment || void 0,
+      `export type ${schemaDefinition.name} = ${JsonSchemaTransformer.toDeclaration(schemaDefinition.schema)}`,
+      "",
+      "/* @anchor:file:end */"
+    ].filter(R8.isNotNil).join("\n");
+  }
+};
+
+// src/transformers/operation-definition/comment.renderer.ts
+import * as R9 from "ramda";
+var CommentRenderer2 = class {
+  constructor(operationDefinition) {
+    this.operationDefinition = operationDefinition;
+  }
+  render() {
+    const operation = this.operationDefinition.operation;
+    if (!operation.summary && !operation.description) return "";
+    const lines = ["/**"];
+    if (operation.summary && typeof operation.summary === "string") {
+      lines.push(` * ${R9.trim(operation.summary)}`);
+      lines.push(" *");
+    }
+    if (operation.description && typeof operation.description === "string") {
+      lines.push(` * @description ${R9.trim(operation.description)}`);
+    }
+    lines.push(" */");
+    return lines.join("\n");
+  }
+};
+
+// src/transformers/operation-definition/declaration.renderer.ts
+import * as R14 from "ramda";
+
+// src/transformers/operation-definition/utils/type-name-factory.ts
+import * as changeCase from "change-case";
+function typeNameFactory(operationDefinition) {
+  const pascalCaseOperationId = changeCase.pascalCase(operationDefinition.operationId);
+  return (name) => `${pascalCaseOperationId}${name}`;
+}
+
+// src/utils/openapi-utils/dereference.ts
+function dereference($ref, swagger) {
+  let value;
+  for (const key of $ref.split("/")) {
+    if (key === "#") {
+      value = swagger;
+    } else {
+      value = value[key];
+    }
+    if (!value) break;
+  }
+  return value;
+}
+
+// src/utils/openapi-utils/dereference-operation.ts
+import * as R12 from "ramda";
 import jsonpointer2 from "jsonpointer";
 import { JSONPath as JSONPath4 } from "jsonpath-plus";
 
 // src/utils/openapi-utils/remove-undefined-ref.ts
-import * as R7 from "ramda";
+import * as R11 from "ramda";
 import jsonpointer from "jsonpointer";
 import { JSONPath as JSONPath3 } from "jsonpath-plus";
 
 // src/utils/openapi-utils/is-ref-defined.ts
-import * as R6 from "ramda";
+import * as R10 from "ramda";
 function isRefDefined($ref, swagger) {
   if ($ref.startsWith("#/")) {
-    const path13 = $ref.replace("#/", "").split("/");
-    return R6.path(path13, swagger) !== void 0;
+    const path12 = $ref.replace("#/", "").split("/");
+    return R10.path(path12, swagger) !== void 0;
   }
   return false;
 }
 
 // src/utils/openapi-utils/remove-undefined-ref.ts
 function removeUndefinedRef(swagger) {
-  const shadow = R7.clone(swagger);
+  const shadow = R11.clone(swagger);
   const matches = JSONPath3({
     path: "$..*['$ref']^",
     json: swagger,
@@ -700,7 +986,7 @@ function removeUndefinedRef(swagger) {
   });
   for (const match of matches) {
     if (match.value.$ref && !isRefDefined(match.value.$ref, swagger)) {
-      jsonpointer.set(shadow, match.pointer, R7.omit(["$ref"], match.value));
+      jsonpointer.set(shadow, match.pointer, R11.omit(["$ref"], match.value));
     }
   }
   return shadow;
@@ -759,7 +1045,7 @@ function dereferenceParameters(swagger) {
   }
 }
 function dereferenceOperation(swagger) {
-  const shadow = R8.clone(swagger);
+  const shadow = R12.clone(swagger);
   dereferencePathObject(shadow);
   dereferenceRequestBody(shadow);
   dereferenceResponses(shadow);
@@ -767,34 +1053,6 @@ function dereferenceOperation(swagger) {
   return removeUndefinedRef(shadow);
 }
 
-// src/utils/json-schema-utils/is-array.ts
-function isArray(schema) {
-  return schema.type === "array";
-}
-
-// src/utils/json-schema-utils/is-mixed.ts
-function isMixed(schema) {
-  return Array.isArray(schema.type);
-}
-
-// src/utils/json-schema-utils/is-non-array.ts
-function isNonArray(schema) {
-  return typeof schema.type === "string" && schema.type !== "array";
-}
-
-// src/utils/json-schema-utils/is-ref.ts
-function isRef(schema) {
-  return "$ref" in schema;
-}
-
-// src/utils/json-schema-utils/index.ts
-var JsonSchemaUtils = class {
-  static isRef = isRef;
-  static isArray = isArray;
-  static isNonArray = isNonArray;
-  static isMixed = isMixed;
-};
-
 // src/utils/openapi-utils/dereference-deep.ts
 function dereferenceDeep($ref, swagger) {
   const stack = [$ref];
@@ -823,9 +1081,9 @@ function To3_1(openapi) {
 }
 
 // src/utils/openapi-utils/map-operation.ts
-import * as R9 from "ramda";
+import * as R13 from "ramda";
 function mapOperation(specification, mapper) {
-  const shadow = R9.clone(specification);
+  const shadow = R13.clone(specification);
   for (const [pathname, pathItem] of Object.entries(shadow.paths || {})) {
     for (const m in pathItem) {
       const method = m.toLowerCase();
@@ -860,628 +1118,87 @@ var OpenapiUtils = class {
   static to3_1 = To3_1;
 };
 
-// src/compiler/tasks/download/index.ts
-function main2(compiler, options) {
-  return {
-    task: (context, task) => {
-      if (!context.rc || !context.matcher) {
-        throw new Error("Please run setup task first.");
+// src/transformers/operation-definition/declaration.renderer.ts
+var alias = (name) => `${name}Schema`;
+var DeclarationRenderer2 = class {
+  constructor(operationDefinition, options) {
+    this.operationDefinition = operationDefinition;
+    this.options = options;
+    this.typeName = typeNameFactory(operationDefinition);
+  }
+  typeName;
+  renderResponseBodies(operation, options) {
+    if (!operation.responses || R14.isEmpty(operation.responses)) {
+      return `export interface ${this.typeName("ResponseBodies")} {}`;
+    }
+    const $responses = Object.entries(operation.responses).map(([statusCode, response]) => {
+      if (!JsonSchemaUtils.isRef(response)) {
+        const $value = Object.entries(response.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).map(([mediaType, schema]) => {
+          if (mediaType.includes("text/event-stream")) return "ReadableStream<ServerSentEvent>";
+          if (mediaType.includes("multipart/form-data")) return "FormData";
+          if (!schema) return "unknown";
+          return JsonSchemaTransformer.toDeclaration(schema, options);
+        }).join(" | ");
+        return indent(2, `${statusCode}: ${$value || "void"}`);
       }
-      const rc = context.rc;
-      const matcher = context.matcher;
-      context.documents = [];
-      return task.newListr(
-        Object.entries(rc.modules).map(([moduleName, address]) => new ModuleDefinition(moduleName, address)).map((moduleDefinition) => ({
-          title: moduleDefinition.name,
-          task: async (ctx, task2) => {
-            if (options?.skipIgnoredModules && matcher.isModuleIgnored(moduleDefinition)) {
-              task2.skip(`(${moduleDefinition.name}) is ignored`);
-              return;
-            }
-            task2.output = `Downloaded from ${moduleDefinition.address}`;
-            const content = await compiler.hooks.download.promise(moduleDefinition.address, moduleDefinition, task2);
-            if (!content) {
-              throw new Exception(moduleDefinition, `Cannot download document from ${moduleDefinition.address}`);
-            }
-            const spec = JSON.parse(content);
-            const { valid, errors } = await validate(spec);
-            if (!valid) {
-              const message = `${moduleDefinition.name} module openapi/swagger file does not conform to the openapi specifications or have grammatical errors, which may cause unexpected errors: 
-${errors?.map((e) => `  - ${e.message}`).join("\n")}`;
-              task2.output = message;
-            }
-            OpenapiUtils.dereferenceOperation(spec);
-            const document = new ApiDocumentV3_1(
-              spec,
-              moduleDefinition
-            );
-            ctx.documents?.push(document);
-          }
-        })),
-        {
-          concurrent: true,
-          exitOnError: false,
-          collectErrors: "minimal",
-          rendererOptions: {
-            collapseSubtasks: false,
-            // collapseSkips: false,
-            suffixSkips: true,
-            timer: PRESET_TIMER
-          }
-        }
-      );
+    }).join("\n");
+    return [
+      `export interface ${this.typeName("ResponseBodies")} {`,
+      $responses,
+      "}"
+    ].join("\n");
+  }
+  renderRequestBodies(operation, options) {
+    let $requestBodies = `export interface ${this.typeName("RequestBodies")} {}`;
+    if (operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody)) {
+      const $mediaTypes = Object.entries(operation.requestBody.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).map(([mediaType, schema]) => {
+        if (!schema) return `${JSON.stringify(mediaType)}: unknown`;
+        return `${JSON.stringify(mediaType)}: ${JsonSchemaTransformer.toDeclaration(schema, options)}`;
+      }).map((pair) => indent(2, pair));
+      $requestBodies = [
+        `export interface ${this.typeName("RequestBodies")} {`,
+        ...$mediaTypes,
+        "}"
+      ].join("\n");
     }
-  };
-}
-function createDownloadTask(compiler, options) {
-  return {
-    title: "Download",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (_, task) => task.newListr(
-      [
-        main2(compiler, options),
-        {
-          task: (context, task2) => compiler.hooks.afterDownload.promise(task2)
+    return $requestBodies;
+  }
+  renderParameterBodies(operationDefinition, options) {
+    const { operation } = operationDefinition;
+    let parameterBodies = "";
+    if (operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody)) {
+      const $mediaTypes = Object.entries(operation.requestBody.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).map(([mediaType, schemaOrRef]) => {
+        if (!schemaOrRef) return `${JSON.stringify(mediaType)}: unknown`;
+        const schema = JsonSchemaUtils.isRef(schemaOrRef) ? OpenapiUtils.dereferenceDeep(schemaOrRef.$ref, operationDefinition.document.specification) : schemaOrRef;
+        if (schema.type === "object" || schema.properties) {
+          return `${JSON.stringify(mediaType)}: ${JsonSchemaTransformer.toDeclaration(schemaOrRef, options)} & { [key: string]: any }`;
         }
-      ],
-      {
-        concurrent: false
-      }
-    )
-  };
-}
-
-// src/compiler/tasks/persist/index.ts
-import * as path6 from "path";
-import fs4 from "fs-extra";
-function createPersistArtifactTask() {
-  return {
-    title: "Write files",
-    task: async (context, task) => {
-      if (!context.rc) throw new Error("Please run setup task first.");
-      if (!context.artifacts || context.artifacts.length === 0) {
-        task.skip("No compiled artifacts to persist.");
-        return;
-      }
-      const rc = context.rc;
-      const artifacts = context.artifacts;
-      const total = artifacts.length;
-      let completed = 0;
-      const files = await Promise.all(artifacts.map(async (artifact) => {
-        const realpath = `./${path6.join(rc.outdir, artifact.filepath)}`;
-        await fs4.ensureFile(realpath);
-        await fs4.writeFile(realpath, artifact.renderer());
-        completed += 1;
-        task.output = `Persisted ${completed}/${total} files`;
-        return new Asset(path6.resolve(realpath));
-      }));
-      context.assets = files;
+        return `${JSON.stringify(mediaType)}: { [key: string]: any }`;
+      }).map((pair) => indent(2, pair));
+      parameterBodies = [
+        `interface ${this.typeName("ParameterBodies")} {`,
+        ...$mediaTypes,
+        "}",
+        ""
+      ].join("\n");
     }
-  };
-}
-function createPersistIgnoreTask() {
-  return {
-    title: "Update .keqignore",
-    task: async (context, task) => {
-      if (!context.matcher) throw new Error("Please run setup task first.");
-      const matcher = context.matcher;
-      await matcher.write(".keqignore");
+    return parameterBodies;
+  }
+  renderRequestParameters(operation, options) {
+    const mediaTypes = operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody) ? Object.keys(operation.requestBody.content || {}) : [];
+    const base = `${this.typeName("RequestQuery")} & ${this.typeName("RouteParameters")} & ${this.typeName("RequestHeaders")}`;
+    if (mediaTypes.length === 1) {
+      return `export type ${this.typeName("RequestParameters")} = ${base} & ${this.typeName("RequestBodies")}[${JSON.stringify(mediaTypes[0])}]`;
     }
-  };
-}
-function main3() {
-  return {
-    task: (context, task) => task.newListr(
-      [
-        createPersistArtifactTask(),
-        createPersistIgnoreTask()
-      ],
-      {
-        concurrent: true,
-        rendererOptions: {
-          collapseSubtasks: true
-        }
-      }
-    )
-  };
-}
-function createPersistTask(compiler, options) {
-  return {
-    title: "Persist",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (context, task) => task.newListr(
-      [
-        main3(),
-        {
-          task: (context2, task2) => compiler.hooks.afterPersist.promise(task2)
-        }
-      ],
-      {
-        concurrent: false
-      }
-    )
-  };
-}
-
-// src/compiler/tasks/compile/index.ts
-function main4(compiler) {
-  return {
-    task: async (context, task) => {
-      if (!context.rc) throw new Error("Please run setup task first.");
-      if (!context.documents) throw new Error("Please run shaking task first.");
-      context.artifacts = [];
-      await compiler.hooks.compile.promise(task);
+    if (mediaTypes.length > 1) {
+      const unions = mediaTypes.map((mediaType) => `(${base} & ${this.typeName("RequestBodies")}[${JSON.stringify(mediaType)}] & { "content-type": ${JSON.stringify(mediaType)} })`).join("\n| ");
+      return `export type ${this.typeName("RequestParameters")} = ${unions}`;
     }
-  };
-}
-function createCompileTask(compiler, options) {
-  return {
-    title: "Compile",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (context, task) => task.newListr(
-      [
-        {
-          task: (context2, task2) => compiler.hooks.beforeCompile.promise(task2)
-        },
-        main4(compiler),
-        {
-          task: (context2, task2) => compiler.hooks.afterCompile.promise(task2)
-        }
-      ],
-      {
-        concurrent: false
-      }
-    )
-  };
-}
-
-// src/compiler/intercepter/print-information.ts
-function proxyTaskWrapper(pluginName, task) {
-  return new Proxy(task, {
-    set(target, prop2, value) {
-      if (prop2 !== "output") {
-        return Reflect.set(target, prop2, value);
-      }
-      target.output = `[Plugin: ${pluginName}] ${value}`;
-      return true;
-    }
-  });
-}
-function printInformation(taskIndex) {
-  return {
-    register: (tap) => {
-      const fn = tap.fn;
-      if (tap.type === "promise") {
-        tap.fn = (...args) => {
-          const task = args[taskIndex];
-          const proxyTask = proxyTaskWrapper(tap.name, task);
-          args[taskIndex] = proxyTask;
-          proxyTask.output = "Processing...";
-          return fn(...args);
-        };
-      }
-      if (tap.type === "sync") {
-        tap.fn = (...args) => {
-          const task = args[taskIndex];
-          const proxyTask = proxyTaskWrapper(tap.name, task);
-          args[taskIndex] = proxyTask;
-          proxyTask.output = "Processing...";
-          return fn(...args);
-        };
-      }
-      if (tap.type === "async") {
-        tap.fn = (...args) => {
-          const task = args[taskIndex];
-          const proxyTask = proxyTaskWrapper(tap.name, task);
-          args[taskIndex] = proxyTask;
-          proxyTask.output = "Processing...";
-          return fn(...args);
-        };
-      }
-      return tap;
-    }
-  };
-}
-
-// src/compiler/intercepter/perfect-error-message.ts
-import * as R10 from "ramda";
-function perfectErrorMessage() {
-  return {
-    register: (tap) => {
-      const fn = tap.fn;
-      function prefix(err) {
-        if (err instanceof Error) {
-          err.message = `[Plugin: ${tap.name}] ${err.message}`;
-        }
-      }
-      if (tap.type === "promise") {
-        tap.fn = async (...args) => {
-          try {
-            return await fn(...args);
-          } catch (err) {
-            prefix(err);
-            throw err;
-          }
-        };
-      }
-      if (tap.type === "sync") {
-        tap.fn = (...args) => {
-          try {
-            return fn(...args);
-          } catch (err) {
-            prefix(err);
-            throw err;
-          }
-        };
-      }
-      if (tap.type === "async") {
-        tap.fn = (...args) => {
-          const callback = R10.last(args);
-          return fn(...R10.init(args), (err, result) => {
-            prefix(err);
-            return callback(err, result);
-          });
-        };
-      }
-      return tap;
-    }
-  };
-}
-
-// src/plugins/eslint/index.ts
-import { ESLint } from "eslint";
-
-// src/plugins/prettier/prettier.plugin.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-
-// src/plugins/body-fallback/index.ts
-import * as R22 from "ramda";
-
-// src/plugins/generate-micro-function/generate-micro-function.plugin.ts
-import { AsyncSeriesWaterfallHook as AsyncSeriesWaterfallHook2 } from "tapable";
-
-// src/plugins/generate-micro-function/constants/metadata-storage.ts
-var MetadataStorage = /* @__PURE__ */ new WeakMap();
-
-// src/plugins/generate-micro-function/generators/micro_function/micro-function.generator.ts
-import * as R21 from "ramda";
-import * as path10 from "path";
-import * as changeCase6 from "change-case";
-
-// src/plugins/generate-declaration/generate-declaration.plugin.ts
-import { AsyncSeriesWaterfallHook } from "tapable";
-
-// src/plugins/generate-declaration/generators/operation-declaration/operation.generator.ts
-import * as path9 from "path";
-import * as changeCase5 from "change-case";
-
-// src/transformers/json-schema/comment.renderer.ts
-var CommentRenderer = class {
-  constructor(schema) {
-    this.schema = schema;
-  }
-  render() {
-    const schema = this.schema;
-    const lines = ["/**"];
-    if (schema.description) {
-      const description = schema.description.replace("*/", "*\\/");
-      lines.push(...description.split("\n").map((line) => ` * ${line}`));
-    }
-    if (schema.deprecated) {
-      lines.push(" * @deprecated");
-    }
-    if (schema.readOnly) {
-      lines.push(" * @readonly");
-    }
-    if (schema.format) {
-      lines.push(` * @format ${schema.format}`);
-    }
-    lines.push(" */");
-    if (lines.length === 2) return "";
-    return lines.join("\n");
-  }
-};
-
-// src/transformers/json-schema/declaration.renderer.ts
-import * as R12 from "ramda";
-
-// src/utils/indent.ts
-function indent(space, text) {
-  if (text === "") return "";
-  const indentation = " ".repeat(space);
-  return text.split("\n").map((line) => line ? `${indentation}${line}` : line).join("\n");
-}
-
-// src/transformers/json-schema/reference.transformer.ts
-import * as R11 from "ramda";
-var ReferenceTransformer = class {
-  static toDeclaration(schema, alias2 = R11.identity) {
-    if (!schema.$ref || !schema.$ref.startsWith("#")) return `unknown /* ${schema.$ref.replace("*/", "*\\/")} */`;
-    const parts = schema.$ref.split("/");
-    return alias2(parts[parts.length - 1]) || "unknown";
-  }
-};
-
-// src/transformers/json-schema/declaration.renderer.ts
-var DeclarationRenderer = class {
-  constructor(schema, options = {}) {
-    this.schema = schema;
-    this.options = options;
-  }
-  render() {
-    return this.renderSchema(this.schema);
-  }
-  renderSchema(schema) {
-    if (typeof schema === "boolean") return "unknown";
-    if (JsonSchemaUtils.isRef(schema)) return this.renderReference(schema);
-    if (JsonSchemaUtils.isMixed(schema)) return this.renderMixed(schema);
-    if (JsonSchemaUtils.isArray(schema)) return this.renderArray(schema);
-    if (schema.type === "object") return this.renderObject(schema);
-    if (schema.enum) return this.renderEnum(schema);
-    if (schema.oneOf) return this.renderOneOf(schema);
-    if (schema.anyOf) return this.renderAnyOf(schema);
-    if (schema.allOf) return this.renderAllOf(schema);
-    if (schema.type === "string") return this.renderString(schema);
-    if (schema.type === "number") return this.renderNumber(schema);
-    if (schema.type === "boolean") return this.renderBoolean(schema);
-    if (schema.type === "null") return this.renderNull(schema);
-    if (schema.type === "integer") return this.renderInteger(schema);
-    return "unknown";
-  }
-  renderMixed(schema) {
-    if (Array.isArray(schema.type)) {
-      schema.type.map((type) => ({ ...schema, type })).map((schema2) => this.renderSchema(schema2)).join(" | ");
-    }
-    return "unknown";
-  }
-  renderReference(schema) {
-    if (!this.options.referenceTransformer) {
-      return ReferenceTransformer.toDeclaration(schema);
-    }
-    return this.options.referenceTransformer(schema);
-  }
-  renderArray(schema) {
-    if (schema.items && Array.isArray(schema.items)) {
-      const items = schema.items.map((s) => this.renderSchema(s)).join(", ");
-      return `[${items}]`;
-    }
-    if (schema.items && typeof schema.items === "object") {
-      return `${this.renderSchema(schema.items)}[]`;
-    }
-    return "any[]";
-  }
-  renderObject(schema) {
-    if ((!schema.properties || R12.isEmpty(schema.properties)) && (!schema.additionalProperties || R12.isEmpty(schema.additionalProperties))) {
-      return "object";
-    }
-    const $properties = Object.entries(schema.properties || {}).map(([propertyName, propertySchema]) => {
-      let $comment = new CommentRenderer(propertySchema).render();
-      if ($comment) $comment += "\n";
-      const $key = `"${propertyName}"${schema.required?.includes(propertyName) ? "" : "?"}`;
-      const $value = this.renderSchema(propertySchema);
-      return indent(2, `${$comment}${$key}: ${$value}`);
-    });
-    if (schema.additionalProperties) {
-      const $value = schema.additionalProperties === true ? "any" : this.renderSchema(schema.additionalProperties);
-      $properties.push(indent(2, `[key: string]: ${$value}`));
-    }
-    return [
-      "{",
-      ...$properties,
-      "}"
-    ].join("\n");
-  }
-  renderOneOf(schema) {
-    if (!schema.oneOf) return "unknown";
-    return schema.oneOf.map((s) => this.renderSchema(s)).join(" | ");
-  }
-  renderAnyOf(schema) {
-    if (!schema.anyOf) return "unknown";
-    return schema.anyOf.map((s) => this.renderSchema(s)).join(" | ");
-  }
-  renderAllOf(schema) {
-    if (!schema.allOf) return "unknown";
-    return schema.allOf.map((s) => this.renderSchema(s)).join(" & ");
-  }
-  renderEnum(schema) {
-    if (!schema.enum) return "unknown";
-    return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
-  }
-  renderString(schema) {
-    if (schema.contentMediaType === "application/octet-stream") return "Blob | Buffer";
-    if (schema.format === "binary") return "Blob | Buffer";
-    return "string";
-  }
-  renderNumber(schema) {
-    return "number";
-  }
-  renderBoolean(schema) {
-    return "boolean";
-  }
-  renderNull(schema) {
-    return "null";
-  }
-  renderInteger(schema) {
-    return "number";
-  }
-};
-
-// src/transformers/json-schema/json-schema.transformer.ts
-var JsonSchemaTransformer = class {
-  static toComment(schema) {
-    return new CommentRenderer(schema).render();
-  }
-  static toDeclaration(schema, options) {
-    return new DeclarationRenderer(schema, options).render();
-  }
-};
-
-// src/transformers/schema-definition/schema-definition.transformer.ts
-import * as R13 from "ramda";
-var SchemaDefinitionTransformer = class {
-  static toDeclaration(schemaDefinition, options) {
-    const dependencies = schemaDefinition.getDependencies();
-    let $dependencies = dependencies.filter((dep) => !SchemaDefinition.isUnknown(dep)).map((dep) => {
-      const filepath = options.getDependentSchemaDefinitionFilepath(dep);
-      return `import type { ${dep.name} } from "${filepath}"`;
-    }).map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, options.esm ? ' from "$1.js"' : ' from "$1"')).join("\n");
-    if ($dependencies) $dependencies += "\n";
-    let $comment = JsonSchemaTransformer.toComment(schemaDefinition.schema);
-    if ($comment) $comment += "\n";
-    if (typeof schemaDefinition.schema === "boolean") {
-      return [
-        "/* @anchor:file:start */",
-        "",
-        $dependencies,
-        $comment || void 0,
-        `type ${schemaDefinition.name} = unknown`,
-        "",
-        "/* @anchor:file:end */"
-      ].filter(R13.isNotNil).join("\n");
-    }
-    if (JsonSchemaUtils.isNonArray(schemaDefinition.schema) && schemaDefinition.schema.type === "object") {
-      const $schema = JsonSchemaTransformer.toDeclaration(schemaDefinition.schema);
-      const $declaration = $schema.startsWith("{") ? `export interface ${schemaDefinition.name} ${$schema}` : `export type ${schemaDefinition.name} = ${$schema}`;
-      return [
-        "/* @anchor:file:start */",
-        "",
-        $dependencies,
-        $comment || void 0,
-        $declaration,
-        "",
-        "/* @anchor:file:end */"
-      ].filter(R13.isNotNil).join("\n");
-    }
-    return [
-      "/* @anchor:file:start */",
-      "",
-      $dependencies,
-      $comment || void 0,
-      `export type ${schemaDefinition.name} = ${JsonSchemaTransformer.toDeclaration(schemaDefinition.schema)}`,
-      "",
-      "/* @anchor:file:end */"
-    ].filter(R13.isNotNil).join("\n");
-  }
-};
-
-// src/transformers/operation-definition/comment.renderer.ts
-import * as R14 from "ramda";
-var CommentRenderer2 = class {
-  constructor(operationDefinition) {
-    this.operationDefinition = operationDefinition;
-  }
-  render() {
-    const operation = this.operationDefinition.operation;
-    if (!operation.summary && !operation.description) return "";
-    const lines = ["/**"];
-    if (operation.summary && typeof operation.summary === "string") {
-      lines.push(` * ${R14.trim(operation.summary)}`);
-      lines.push(" *");
-    }
-    if (operation.description && typeof operation.description === "string") {
-      lines.push(` * @description ${R14.trim(operation.description)}`);
-    }
-    lines.push(" */");
-    return lines.join("\n");
-  }
-};
-
-// src/transformers/operation-definition/declaration.renderer.ts
-import * as R15 from "ramda";
-
-// src/transformers/operation-definition/utils/type-name-factory.ts
-import * as changeCase from "change-case";
-function typeNameFactory(operationDefinition) {
-  const pascalCaseOperationId = changeCase.pascalCase(operationDefinition.operationId);
-  return (name) => `${pascalCaseOperationId}${name}`;
-}
-
-// src/transformers/operation-definition/declaration.renderer.ts
-var alias = (name) => `${name}Schema`;
-var DeclarationRenderer2 = class {
-  constructor(operationDefinition, options) {
-    this.operationDefinition = operationDefinition;
-    this.options = options;
-    this.typeName = typeNameFactory(operationDefinition);
-  }
-  typeName;
-  renderResponseBodies(operation, options) {
-    if (!operation.responses || R15.isEmpty(operation.responses)) {
-      return `export interface ${this.typeName("ResponseBodies")} {}`;
-    }
-    const $responses = Object.entries(operation.responses).map(([statusCode, response]) => {
-      if (!JsonSchemaUtils.isRef(response)) {
-        const $value = Object.entries(response.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).map(([mediaType, schema]) => {
-          if (mediaType.includes("text/event-stream")) return "ReadableStream<ServerSentEvent>";
-          if (mediaType.includes("multipart/form-data")) return "FormData";
-          if (!schema) return "unknown";
-          return JsonSchemaTransformer.toDeclaration(schema, options);
-        }).join(" | ");
-        return indent(2, `${statusCode}: ${$value || "void"}`);
-      }
-    }).join("\n");
-    return [
-      `export interface ${this.typeName("ResponseBodies")} {`,
-      $responses,
-      "}"
-    ].join("\n");
-  }
-  renderRequestBodies(operation, options) {
-    let $requestBodies = `export interface ${this.typeName("RequestBodies")} {}`;
-    if (operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody)) {
-      const $mediaTypes = Object.entries(operation.requestBody.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).map(([mediaType, schema]) => {
-        if (!schema) return `${JSON.stringify(mediaType)}: unknown`;
-        return `${JSON.stringify(mediaType)}: ${JsonSchemaTransformer.toDeclaration(schema, options)}`;
-      }).map((pair) => indent(2, pair));
-      $requestBodies = [
-        `export interface ${this.typeName("RequestBodies")} {`,
-        ...$mediaTypes,
-        "}"
-      ].join("\n");
-    }
-    return $requestBodies;
-  }
-  renderParameterBodies(operationDefinition, options) {
-    const { operation } = operationDefinition;
-    let parameterBodies = "";
-    if (operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody)) {
-      const $mediaTypes = Object.entries(operation.requestBody.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).map(([mediaType, schemaOrRef]) => {
-        if (!schemaOrRef) return `${JSON.stringify(mediaType)}: unknown`;
-        const schema = JsonSchemaUtils.isRef(schemaOrRef) ? OpenapiUtils.dereferenceDeep(schemaOrRef.$ref, operationDefinition.document.specification) : schemaOrRef;
-        if (schema.type === "object" || schema.properties) {
-          return `${JSON.stringify(mediaType)}: ${JsonSchemaTransformer.toDeclaration(schemaOrRef, options)} & { [key: string]: any }`;
-        }
-        return `${JSON.stringify(mediaType)}: { [key: string]: any }`;
-      }).map((pair) => indent(2, pair));
-      parameterBodies = [
-        `interface ${this.typeName("ParameterBodies")} {`,
-        ...$mediaTypes,
-        "}",
-        ""
-      ].join("\n");
-    }
-    return parameterBodies;
-  }
-  renderRequestParameters(operation, options) {
-    const mediaTypes = operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody) ? Object.keys(operation.requestBody.content || {}) : [];
-    const base = `${this.typeName("RequestQuery")} & ${this.typeName("RouteParameters")} & ${this.typeName("RequestHeaders")}`;
-    if (mediaTypes.length === 1) {
-      return `export type ${this.typeName("RequestParameters")} = ${base} & ${this.typeName("RequestBodies")}[${JSON.stringify(mediaTypes[0])}]`;
-    }
-    if (mediaTypes.length > 1) {
-      const unions = mediaTypes.map((mediaType) => `(${base} & ${this.typeName("RequestBodies")}[${JSON.stringify(mediaType)}] & { "content-type": ${JSON.stringify(mediaType)} })`).join("\n| ");
-      return `export type ${this.typeName("RequestParameters")} = ${unions}`;
-    }
-    return `export type ${this.typeName("RequestParameters")} = ${base}`;
-  }
-  rendererParameters(name, parameters, options) {
-    if (parameters.length === 0) {
-      return `export type ${name} = {}`;
+    return `export type ${this.typeName("RequestParameters")} = ${base}`;
+  }
+  rendererParameters(name, parameters, options) {
+    if (parameters.length === 0) {
+      return `export type ${name} = {}`;
     }
     const $parameters = parameters.map((parameter) => {
       const parameterName = `"${parameter.name}"`;
@@ -1562,15 +1279,28 @@ var DeclarationRenderer2 = class {
       "}",
       "",
       "/* @anchor:file:end */"
-    ].filter(R15.isNotNil).join("\n");
+    ].filter(R14.isNotNil).join("\n");
   }
 };
 
 // src/transformers/operation-definition/micro-function.renderer.ts
-import * as R17 from "ramda";
+import * as R16 from "ramda";
+
+// src/exception.ts
+import { CustomError } from "ts-custom-error";
+import wrap from "word-wrap";
+var Exception = class extends CustomError {
+  constructor(module, message) {
+    const moduleName = typeof module === "string" ? module : module.name;
+    const msg = wrap(message, { width: 60, indent: "    " });
+    super(`${moduleName} module failed to compile:
+${msg}`);
+    Object.defineProperty(this, "name", { value: "KeqCLI_Exception" });
+  }
+};
 
 // src/transformers/operation-definition/typescript-snippet.ts
-import * as R16 from "ramda";
+import * as R15 from "ramda";
 
 // src/constants/qs-array-format.ts
 var QsArrayFormat = /* @__PURE__ */ ((QsArrayFormat2) => {
@@ -1640,7 +1370,7 @@ var OperationDefinitionSnippet = class {
     const { operation } = this.operationDefinition;
     const $query = (operation.parameters || []).filter((p) => !JsonSchemaUtils.isRef(p)).filter((p) => p.in === "query").map((p) => {
       const option = this.getQsParameters(p);
-      const $option = !option || R16.isEmpty(option) ? "" : `, ${JSON.stringify(option)}`;
+      const $option = !option || R15.isEmpty(option) ? "" : `, ${JSON.stringify(option)}`;
       return `if (args && ${JSON.stringify(p.name)} in args) req.query(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}]${$option})`;
     }).join("\n");
     return $query;
@@ -1710,7 +1440,7 @@ var OperationDefinitionSnippet = class {
       } catch (err) {
         return this.renderErrorComment(err, mediaType);
       }
-    }).filter(R16.isNotNil).join("\n");
+    }).filter(R15.isNotNil).join("\n");
     return $requestBody;
   }
   renderErrorComment(err, mediaType) {
@@ -1785,7 +1515,7 @@ var OperationDefinitionMicroFunctionRenderer = class {
       `${operationId}.pathname = pathname`,
       `${operationId}.method = method`,
       "/* @anchor:file:end */"
-    ].filter(R17.isNotNil).join("\n");
+    ].filter(R16.isNotNil).join("\n");
   }
   renderDependencies() {
     const declarationFilepath = this.options.getOperationDefinitionDeclarationFilepath(this.operationDefinition);
@@ -1812,7 +1542,7 @@ var OperationDefinitionMicroFunctionRenderer = class {
 };
 
 // src/transformers/operation-definition/nestjs-method.renderer.ts
-import * as R18 from "ramda";
+import * as R17 from "ramda";
 var OperationDefinitionNestjsMethodRenderer = class {
   constructor(operationDefinition, options) {
     this.operationDefinition = operationDefinition;
@@ -1865,7 +1595,7 @@ var OperationDefinitionNestjsMethodRenderer = class {
       "",
       "  return req",
       "}"
-    ].filter(R18.isNotNil).join("\n");
+    ].filter(R17.isNotNil).join("\n");
   }
   renderOperationDeclaration(operationDefinition) {
     const { operationId } = operationDefinition;
@@ -1899,11 +1629,11 @@ var OperationDefinitionTransformer = class {
 };
 
 // src/transformers/entrypoint/entrypoint.transformer.ts
-import * as path7 from "path";
+import * as path5 from "path";
 var EntrypointTransformer = class {
   static toTypescript(exports, options) {
     const $exports = exports.map((exportArtifact) => {
-      const relativePath = path7.relative(
+      const relativePath = path5.relative(
         options.dirpath,
         exportArtifact.filepath
       ).replace(/(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?$/, options.esm ? ".js" : "");
@@ -1920,128 +1650,26 @@ var EntrypointTransformer = class {
 };
 
 // src/transformers/api-document/nestjs-client.renderer.ts
-import * as R19 from "ramda";
+import * as R18 from "ramda";
 import * as changeCase2 from "change-case";
-var NestjsClientRenderer = class {
-  constructor(document, options) {
-    this.document = document;
-    this.options = options;
-  }
-  renderDependencies() {
-    const $operations = this.document.operations.map((operationDefinition) => {
-      const filepath = this.options.getOperationDefinitionDeclarationFilepath(operationDefinition);
-      const typeName = typeNameFactory(operationDefinition);
-      return `import type { ${typeName("Operation")}, ${typeName("ResponseBodies")}, ${typeName("RequestParameters")} } from "${filepath}"`;
-    }).map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, this.options.esm ? ' from "$1.js"' : ' from "$1"'));
-    return [
-      'import { Injectable, Logger } from "@nestjs/common"',
-      'import { Keq, KeqRequest } from "keq"',
-      ...$operations
-    ].join("\n");
-  }
-  render() {
-    const moduleName = changeCase2.pascalCase(this.document.module.name);
-    const $dependencies = this.renderDependencies();
-    const $operations = this.document.operations.map((operation) => OperationDefinitionTransformer.toNestjsMethod(operation, {
-      esm: this.options.esm
-    })).join("\n\n");
-    return [
-      "/* @anchor:file:start */",
-      "",
-      $dependencies,
-      "",
-      "@Injectable()",
-      `export class ${moduleName}Client {`,
-      `  private readonly logger = new Logger(${moduleName}Client.name)`,
-      "",
-      "  constructor(",
-      "    // @anchor:client-constructor-parameters:start",
-      "    private readonly request: KeqRequest,",
-      "    // @anchor:client-constructor-parameters:end",
-      "  ) {}",
-      "",
-      indent(2, $operations),
-      "}",
-      "",
-      "/* @anchor:file:end */"
-    ].filter(R19.isNotNil).join("\n");
-  }
-};
 
 // src/transformers/api-document/nestjs-module.renderer.ts
 import * as changeCase3 from "change-case";
-var NestjsModuleRenderer = class {
-  constructor(document, options) {
-    this.document = document;
-    this.options = options;
-  }
-  render() {
-    const moduleName = changeCase3.pascalCase(this.document.module.name);
-    const clientFilepath = this.options.getNestjsClientFilepath(this.document).replace(/(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?$/, this.options.esm ? ".js" : "");
-    return [
-      "/* @anchor:file:start */",
-      'import { Module, Inject, ConfigurableModuleBuilder, Global } from "@nestjs/common"',
-      'import { KeqRequest } from "keq"',
-      'import { KeqModuleOptions } from "@keq-request/nestjs"',
-      `import { ${moduleName}Client } from "${clientFilepath}"`,
-      "",
-      "",
-      "const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } = new ConfigurableModuleBuilder<KeqModuleOptions>().build()",
-      "",
-      "@Global()",
-      "@Module({",
-      "  imports: [],",
-      "  controllers: [],",
-      `  providers: [${moduleName}Client],`,
-      `  exports: [${moduleName}Client],`,
-      "})",
-      `export class ${moduleName}Module extends ConfigurableModuleClass {`,
-      "",
-      "  constructor(",
-      "    @Inject(MODULE_OPTIONS_TOKEN) private readonly options: KeqModuleOptions,",
-      "    private readonly request: KeqRequest,",
-      "  ) {",
-      "    super()",
-      "  }",
-      "",
-      "  onModuleInit() {",
-      "    if (this.options.middlewares) {",
-      "      for (const middleware of this.options.middlewares) {",
-      "        this.request.use(middleware)",
-      "      }",
-      "    }",
-      "  }",
-      "}",
-      "",
-      "/* @anchor:file:end */"
-    ].join("\n");
-  }
-};
-
-// src/transformers/api-document/api-document.transformer.ts
-var ApiDocumentTransformer = class {
-  static toNestjsModule(document, options) {
-    return new NestjsModuleRenderer(document, options).render();
-  }
-  static toNestjsClient(document, options) {
-    return new NestjsClientRenderer(document, options).render();
-  }
-};
 
 // src/plugins/generate-declaration/generators/schema-declaration/schema.generator.ts
-import * as R20 from "ramda";
-import * as path8 from "path";
+import * as R19 from "ramda";
+import * as path6 from "path";
 import * as changeCase4 from "change-case";
 
 // src/plugins/generate-declaration/constants/metadata-storage.ts
-var MetadataStorage2 = /* @__PURE__ */ new WeakMap();
+var MetadataStorage4 = /* @__PURE__ */ new WeakMap();
 
 // src/plugins/generate-declaration/generators/schema-declaration/schema.generator.ts
 var SCHEMA_GENERATOR = "schemaGenerator";
 var SchemaDeclarationGenerator = class _SchemaDeclarationGenerator {
   async compile(compiler, task) {
     const context = compiler.context;
-    const metadata = MetadataStorage2.get(compiler);
+    const metadata = MetadataStorage4.get(compiler);
     const rc = context.rc;
     const documents = context.documents;
     const schemaDefinitions = documents.flatMap((document) => document.schemas);
@@ -2057,7 +1685,7 @@ var SchemaDeclarationGenerator = class _SchemaDeclarationGenerator {
         ])
       )
     );
-    const entrypoints = R20.collectBy(
+    const entrypoints = R19.collectBy(
       (schemaDefinition) => schemaDefinition.module.name,
       schemaDefinitions
     ).map((schemaDefinitions2) => [
@@ -2072,7 +1700,7 @@ var SchemaDeclarationGenerator = class _SchemaDeclarationGenerator {
   }
   generateSchemaDefinitionsArtifact(schemaDefinition, rc) {
     const filepath = _SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(schemaDefinition, rc.fileNamingStyle);
-    const dirpath = path8.dirname(filepath);
+    const dirpath = path6.dirname(filepath);
     const artifact = new Artifact({
       id: _SchemaDeclarationGenerator.getSchemaDefinitionArtifactId(schemaDefinition),
       filepath,
@@ -2081,7 +1709,7 @@ var SchemaDeclarationGenerator = class _SchemaDeclarationGenerator {
         {
           esm: rc.esm,
           getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
-            const relativePath = path8.relative(
+            const relativePath = path6.relative(
               dirpath,
               _SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.fileNamingStyle)
             );
@@ -2095,7 +1723,7 @@ var SchemaDeclarationGenerator = class _SchemaDeclarationGenerator {
   }
   generateEntrypointArtifact(moduleDefinition, exports, rc) {
     const filepath = _SchemaDeclarationGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.fileNamingStyle);
-    const dirpath = path8.dirname(filepath);
+    const dirpath = path6.dirname(filepath);
     const artifact = new Artifact({
       id: _SchemaDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
       filepath,
@@ -2114,7 +1742,7 @@ var SchemaDeclarationGenerator = class _SchemaDeclarationGenerator {
     ].join("/");
   }
   static getEntrypointArtifactId(moduleDefinition) {
-    return `${moduleDefinition.address}/components/schemas/entrypoint?generator=${SCHEMA_GENERATOR}`;
+    return `${moduleDefinition.address.url}/components/schemas/entrypoint?generator=${SCHEMA_GENERATOR}`;
   }
   static getSchemaDefinitionArtifactFilepath(schemaDefinition, fileNamingStyle) {
     const filename = `${changeCase4[fileNamingStyle](schemaDefinition.name)}.schema.ts`;
@@ -2137,7 +1765,7 @@ var OPERATION_GENERATOR = "operationDeclarationGenerator";
 var OperationDeclarationGenerator = class _OperationDeclarationGenerator {
   async compile(compiler, task) {
     const context = compiler.context;
-    const metadata = MetadataStorage2.get(compiler);
+    const metadata = MetadataStorage4.get(compiler);
     const rc = context.rc;
     const documents = context.documents;
     const operationDefinitions = documents.flatMap((document) => document.operations);
@@ -2157,7 +1785,7 @@ var OperationDeclarationGenerator = class _OperationDeclarationGenerator {
   }
   generateOperationDefinitionArtifact(operationDefinition, rc) {
     const filepath = _OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.fileNamingStyle);
-    const dirpath = path9.dirname(filepath);
+    const dirpath = path7.dirname(filepath);
     const artifact = new Artifact({
       id: _OperationDeclarationGenerator.getOperationDefinitionArtifactId(operationDefinition),
       filepath,
@@ -2166,7 +1794,7 @@ var OperationDeclarationGenerator = class _OperationDeclarationGenerator {
         {
           esm: rc.esm,
           getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
-            const relativePath = path9.relative(
+            const relativePath = path7.relative(
               dirpath,
               SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.fileNamingStyle)
             );
@@ -2180,7 +1808,7 @@ var OperationDeclarationGenerator = class _OperationDeclarationGenerator {
   }
   generateEntrypointArtifact(moduleDefinition, exports, rc) {
     const filepath = _OperationDeclarationGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.fileNamingStyle);
-    const dirpath = path9.dirname(filepath);
+    const dirpath = path7.dirname(filepath);
     const artifact = new Artifact({
       id: _OperationDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
       filepath,
@@ -2212,7 +1840,7 @@ var OperationDeclarationGenerator = class _OperationDeclarationGenerator {
     ].join("/");
   }
   static getEntrypointArtifactId(moduleDefinition) {
-    return `${moduleDefinition.address}/paths/entrypoint?generator=${OPERATION_GENERATOR}`;
+    return `${moduleDefinition.address.url}/paths/entrypoint?generator=${OPERATION_GENERATOR}`;
   }
 };
 
@@ -2225,6 +1853,7 @@ var GenerateDeclarationPlugin = class _GenerateDeclarationPlugin {
   constructor() {
   }
   apply(compiler) {
+    if (MetadataStorage4.has(compiler)) return;
     _GenerateDeclarationPlugin.register(compiler);
     compiler.hooks.compile.tapPromise(_GenerateDeclarationPlugin.name, async (task) => {
       compiler.context.artifacts?.push(
@@ -2234,8 +1863,8 @@ var GenerateDeclarationPlugin = class _GenerateDeclarationPlugin {
     });
   }
   static register(compiler) {
-    if (!MetadataStorage2.has(compiler)) {
-      MetadataStorage2.set(compiler, {
+    if (!MetadataStorage4.has(compiler)) {
+      MetadataStorage4.set(compiler, {
         hooks: {
           afterEntrypointArtifactGenerated: new AsyncSeriesWaterfallHook(["artifact", "task"]),
           afterSchemaDeclarationArtifactGenerated: new AsyncSeriesWaterfallHook(["artifact", "schemaDefinition", "task"]),
@@ -2243,7 +1872,7 @@ var GenerateDeclarationPlugin = class _GenerateDeclarationPlugin {
         }
       });
     }
-    return MetadataStorage2.get(compiler);
+    return MetadataStorage4.get(compiler);
   }
   static of(compiler) {
     return this.register(compiler);
@@ -2288,7 +1917,7 @@ var RequestGenerator = class _RequestGenerator {
 var MICRO_FUNCTION_GENERATOR = "microFunctionGenerator";
 var MicroFunctionGenerator = class _MicroFunctionGenerator {
   async compile(compiler, task) {
-    const metadata = MetadataStorage.get(compiler);
+    const metadata = MetadataStorage3.get(compiler);
     const context = compiler.context;
     const rc = context.rc;
     const documents = context.documents;
@@ -2306,7 +1935,7 @@ var MicroFunctionGenerator = class _MicroFunctionGenerator {
       )
     );
     const entrypoints = await Promise.all(
-      R21.collectBy(
+      R20.collectBy(
         (operationDefinition) => operationDefinition.module.name,
         operationDefinitions
       ).map((operationDefinitions2) => [
@@ -2325,21 +1954,21 @@ var MicroFunctionGenerator = class _MicroFunctionGenerator {
   }
   generateOperationDefinitionArtifact(operationDefinition, rc) {
     const filepath = _MicroFunctionGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.fileNamingStyle);
-    const dirpath = path10.dirname(filepath);
+    const dirpath = path8.dirname(filepath);
     const artifact = new Artifact({
       id: _MicroFunctionGenerator.getOperationDefinitionArtifactId(operationDefinition),
       filepath,
       content: OperationDefinitionTransformer.toMicroFunction(operationDefinition, {
         esm: rc.esm,
         getOperationDefinitionDeclarationFilepath(operationDefinition2) {
-          const relativePath = path10.relative(
+          const relativePath = path8.relative(
             dirpath,
             OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition2, rc.fileNamingStyle)
           );
           return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
         },
         getRequestFilepath() {
-          const relativePath = path10.relative(
+          const relativePath = path8.relative(
             dirpath,
             RequestGenerator.getRequestArtifactFilepath()
           );
@@ -2391,6 +2020,7 @@ var GenerateMicroFunctionPlugin = class _GenerateMicroFunctionPlugin {
   microFunctionGenerator = new MicroFunctionGenerator();
   requestGenerator = new RequestGenerator();
   apply(compiler) {
+    if (MetadataStorage3.has(compiler)) return;
     _GenerateMicroFunctionPlugin.register(compiler);
     compiler.hooks.compile.tapPromise(_GenerateMicroFunctionPlugin.name, async (task) => {
       const artifacts = [
@@ -2401,15 +2031,15 @@ var GenerateMicroFunctionPlugin = class _GenerateMicroFunctionPlugin {
     });
   }
   static register(compiler) {
-    if (!MetadataStorage.has(compiler)) {
-      MetadataStorage.set(compiler, {
+    if (!MetadataStorage3.has(compiler)) {
+      MetadataStorage3.set(compiler, {
         hooks: {
           afterEntrypointArtifactGenerated: new AsyncSeriesWaterfallHook2(["artifact", "task"]),
           afterMicroFunctionArtifactGenerated: new AsyncSeriesWaterfallHook2(["artifact", "operationDefinition", "task"])
         }
       });
     }
-    return MetadataStorage.get(compiler);
+    return MetadataStorage3.get(compiler);
   }
   static of(compiler) {
     return this.register(compiler);
@@ -2419,328 +2049,646 @@ var GenerateMicroFunctionPlugin = class _GenerateMicroFunctionPlugin {
 // src/plugins/generate-nestjs-module/generate-nestjs-module.ts
 import { AsyncSeriesWaterfallHook as AsyncSeriesWaterfallHook3 } from "tapable";
 
-// src/plugins/generate-nestjs-module/constants/metadata-storage.ts
-var MetadataStorage3 = /* @__PURE__ */ new WeakMap();
-
 // src/plugins/generate-nestjs-module/generators/nestjs-module.generator.ts
-import * as path11 from "path";
 import * as changeCase7 from "change-case";
-var NESTJS_MODULE_GENERATOR = "nestjs-module-generator";
-var NestjsModuleGenerator = class _NestjsModuleGenerator {
-  generateNestjsModuleArtifact(document, rc) {
-    const filepath = _NestjsModuleGenerator.getNestjsModuleArtifactFilepath(document, rc.fileNamingStyle);
-    const dirname6 = path11.dirname(filepath);
-    const artifact = new Artifact({
-      id: _NestjsModuleGenerator.getNestjsModuleArtifactId(document),
-      filepath,
-      content: ApiDocumentTransformer.toNestjsModule(document, {
-        esm: rc.esm,
-        getNestjsClientFilepath(document2) {
-          const relativePath = path11.relative(
-            dirname6,
-            _NestjsModuleGenerator.getNestjsClientArtifactFilepath(document2, rc.fileNamingStyle)
-          );
-          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-        }
-      })
+
+// src/plugins/chinese-to-pinyin/chinese-to-pinyin.plugin.ts
+import { fixSwagger } from "swagger-fix";
+
+// src/plugins/download-http-file/constants/metadata-storage.ts
+var MetadataStorage8 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/download-http-file/download-http-file.plugin.ts
+var DownloadHttpFilePlugin = class _DownloadHttpFilePlugin {
+  apply(compiler) {
+    if (MetadataStorage8.has(compiler)) return;
+    _DownloadHttpFilePlugin.register(compiler);
+    compiler.hooks.download.tapPromise(_DownloadHttpFilePlugin.name, async (address, task) => {
+      const { url } = address;
+      if (!url.startsWith("http://") && !url.startsWith("https://")) return void 0;
+      const content = await this.download(address);
+      const spec = this.deserialize(content);
+      return JSON.stringify(spec);
     });
-    return artifact;
   }
-  generateNestjsClientArtifact(document, rc) {
-    const filepath = _NestjsModuleGenerator.getNestjsClientArtifactFilepath(document, rc.fileNamingStyle);
-    const dirpath = path11.dirname(filepath);
-    const artifact = new Artifact({
-      id: _NestjsModuleGenerator.getNestjsClientArtifactId(document),
-      filepath,
-      content: ApiDocumentTransformer.toNestjsClient(document, {
-        esm: rc.esm,
-        getOperationDefinitionDeclarationFilepath(operationDefinition) {
-          const relativePath = path11.relative(
-            dirpath,
-            OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.fileNamingStyle)
-          );
-          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-        }
-      })
+  async download(address) {
+    const { url, headers } = address;
+    try {
+      const res = await fetch(url, { headers });
+      if (res.status >= 400) throw new Error(`failed with status code ${res.status}`);
+      return await res.text();
+    } catch (e) {
+      if (e instanceof Error) {
+        e.message = `Unable get the openapi/swagger file from ${url}: ${e.message}`;
+      }
+      throw e;
+    }
+  }
+  deserialize(content) {
+    const json = JSON.parse(content);
+    const spec = OpenapiUtils.to3_1(json);
+    return spec;
+  }
+  static register(compiler) {
+    if (!MetadataStorage8.has(compiler)) {
+      MetadataStorage8.set(compiler, {
+        hooks: {}
+      });
+    }
+    return MetadataStorage8.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+};
+
+// src/plugins/download-local-file/download-local-file.plugin.ts
+import * as path9 from "path";
+import * as fs3 from "fs/promises";
+import * as yaml from "js-yaml";
+import { fileURLToPath } from "url";
+
+// src/plugins/download-local-file/constants/metadata-storage.ts
+var MetadataStorage9 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/download-local-file/download-local-file.plugin.ts
+var DownloadLocalFilePlugin = class _DownloadLocalFilePlugin {
+  apply(compiler) {
+    if (MetadataStorage9.has(compiler)) return;
+    _DownloadLocalFilePlugin.register(compiler);
+    compiler.hooks.download.tapPromise(_DownloadLocalFilePlugin.name, async (address, task) => {
+      const { url, encoding } = address;
+      if (!url.startsWith("file://")) return void 0;
+      const filepath = fileURLToPath(url);
+      const fileExt = path9.extname(filepath);
+      const content = await fs3.readFile(filepath, encoding);
+      const str = typeof content === "string" ? content : content.toString(encoding);
+      if ([".yml", ".yaml"].includes(fileExt)) {
+        const value = yaml.load(str);
+        return JSON.stringify(OpenapiUtils.to3_1(value));
+      } else if (fileExt === ".json") {
+        return JSON.stringify(OpenapiUtils.to3_1(JSON.parse(str)));
+      }
     });
-    return artifact;
   }
-  async compile(compiler, task) {
-    const metadata = MetadataStorage3.get(compiler);
+  static register(compiler) {
+    if (!MetadataStorage9.has(compiler)) {
+      MetadataStorage9.set(compiler, {
+        hooks: {}
+      });
+    }
+    return MetadataStorage9.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+};
+
+// src/plugins/shaking/shaking.plugin.ts
+import { openapiShakingSync } from "@opendoc/openapi-shaking";
+
+// src/plugins/shaking/constants/metadata-storage.ts
+var MetadataStorage10 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/shaking/shaking.plugin.ts
+var ShakingPlugin = class _ShakingPlugin {
+  apply(compiler) {
+    if (MetadataStorage10.has(compiler)) return;
+    _ShakingPlugin.register(compiler);
+    compiler.hooks.beforeCompile.tap(_ShakingPlugin.name, (task) => {
+      const matcher = compiler.context.matcher;
+      const documents = compiler.context.documents;
+      compiler.context.documents = documents.map((document) => this.shaking(compiler, document)).filter((document) => !document.isEmpty()).filter((document) => !matcher.isModuleIgnored(document.module));
+    });
+  }
+  shaking(compiler, document) {
     const rc = compiler.context.rc;
-    const documents = compiler.context.documents;
-    const nestjsModuleArtifacts = await Promise.all(
-      documents.map((document) => metadata.hooks.afterNestjsModuleArtifactGenerated.promise(
-        this.generateNestjsModuleArtifact(document, rc),
-        document,
-        task
-      ))
+    const matcher = compiler.context.matcher;
+    const isAccepted = (pathname, method, operation) => {
+      if (!SupportedMethods.includes(method)) return false;
+      return !matcher.isOperationIgnored(new OperationDefinition({
+        method,
+        pathname,
+        operation,
+        module: document.module,
+        document
+      }));
+    };
+    const sharkedSwagger = openapiShakingSync(
+      document.specification,
+      isAccepted,
+      { tolerant: rc.tolerant }
     );
-    const nestjsClientArtifacts = await Promise.all(
-      documents.map((document) => metadata.hooks.afterNestjsModuleArtifactGenerated.promise(
-        this.generateNestjsClientArtifact(document, rc),
-        document,
-        task
-      ))
+    return new ApiDocumentV3_1(
+      sharkedSwagger,
+      new ModuleDefinition(
+        document.module.name,
+        {
+          url: `memory://${document.module.name}.v3_1.sharked.json`,
+          headers: {},
+          encoding: "utf8"
+        }
+      )
     );
-    return [...nestjsModuleArtifacts, ...nestjsClientArtifacts];
-  }
-  static getNestjsModuleArtifactFilepath(document, fileNamingStyle) {
-    const filename = `${changeCase7[fileNamingStyle](document.module.name)}.module.ts`;
-    const filepath = [
-      ".",
-      changeCase7[fileNamingStyle](document.module.name),
-      filename
-    ];
-    return filepath.join("/");
   }
-  static getNestjsModuleArtifactId(document) {
-    return `${document.module.address}?generate=${NESTJS_MODULE_GENERATOR}`;
-  }
-  static getNestjsClientArtifactFilepath(document, fileNamingStyle) {
-    const filename = `${changeCase7[fileNamingStyle](document.module.name)}.client.ts`;
-    const filepath = [
-      ".",
-      changeCase7[fileNamingStyle](document.module.name),
-      filename
-    ];
-    return filepath.join("/");
+  static register(compiler) {
+    if (!MetadataStorage10.has(compiler)) {
+      MetadataStorage10.set(compiler, {
+        hooks: {}
+      });
+    }
+    return MetadataStorage10.get(compiler);
   }
-  static getNestjsClientArtifactId(document) {
-    return `${document.module.address}?generate=${NESTJS_MODULE_GENERATOR}-client`;
+  static of(compiler) {
+    return this.register(compiler);
   }
 };
 
-// src/plugins/generate-nestjs-module/generate-nestjs-module.ts
-var GenerateNestjsModulePlugin = class _GenerateNestjsModulePlugin {
-  nestjsModuleGenerator = new NestjsModuleGenerator();
+// src/plugins/terminal-select/utils/select-operation-definitions.ts
+import { select } from "inquirer-select-pro";
+import { ListrInquirerPromptAdapter } from "@listr2/prompt-adapter-inquirer";
+async function selectOperationDefinitions(task, operationDefinitions) {
+  const selectedOperationDefinitions = await task.prompt(ListrInquirerPromptAdapter).run(
+    select,
+    {
+      message: "Select Pathname",
+      defaultValue: [],
+      options: (input) => {
+        const items = operationDefinitions.map((op) => ({ name: `${op.module.name} ${op.method.toUpperCase()} ${op.pathname}`, value: op }));
+        if (!input) return items;
+        const keys2 = input.trim().toLowerCase().split(/\s+/);
+        return items.filter((i) => {
+          const name = i.name.toLowerCase();
+          return keys2.every((q) => name.includes(q));
+        });
+      }
+    }
+  );
+  return selectedOperationDefinitions;
+}
+
+// src/plugins/terminal-select/constants/metadata-storage.ts
+var MetadataStorage11 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/terminal-select/terminal-select.plugin.ts
+var TerminalSelectPlugin = class _TerminalSelectPlugin {
+  constructor(options) {
+    this.options = options;
+  }
   apply(compiler) {
-    _GenerateNestjsModulePlugin.register(compiler);
-    compiler.hooks.compile.tapPromise(_GenerateNestjsModulePlugin.name, async (task) => {
-      const artifacts = await this.nestjsModuleGenerator.compile(compiler, task);
-      compiler.context.artifacts.push(...artifacts);
+    if (MetadataStorage11.has(compiler)) return;
+    _TerminalSelectPlugin.register(compiler);
+    compiler.hooks.afterDownload.tapPromise(_TerminalSelectPlugin.name, async (task) => {
+      const context = compiler.context;
+      const matcher = context.matcher;
+      const documents = context.documents;
+      const operationDefinitions = documents.flatMap((document) => document.operations);
+      const selectedOperationDefinitions = await selectOperationDefinitions(task, operationDefinitions);
+      if (this.options.clear) {
+        matcher.append({
+          persist: false,
+          ignore: true,
+          moduleName: "*",
+          operationMethod: "*",
+          operationPathname: "*"
+        });
+      }
+      for (const op of selectedOperationDefinitions) {
+        matcher.append({
+          persist: !!this.options.persist,
+          ignore: this.options.mode === "add",
+          moduleName: op.module.name,
+          operationMethod: op.method,
+          operationPathname: op.pathname
+        });
+      }
     });
   }
-  static register(compiler) {
-    if (!MetadataStorage3.has(compiler)) {
-      MetadataStorage3.set(compiler, {
-        hooks: {
-          afterNestjsModuleArtifactGenerated: new AsyncSeriesWaterfallHook3(["artifact", "document", "task"])
-        }
+  static register(compiler) {
+    if (!MetadataStorage11.has(compiler)) {
+      MetadataStorage11.set(compiler, {
+        hooks: {}
       });
     }
-    return MetadataStorage3.get(compiler);
+    return MetadataStorage11.get(compiler);
   }
   static of(compiler) {
-    return MetadataStorage3.get(compiler);
+    return this.register(compiler);
   }
 };
 
-// src/plugins/chinese-to-pinyin/chinese-to-pinyin.plugin.ts
-import { fixSwagger } from "swagger-fix";
-
-// src/plugins/download-http-file/download-http-file.plugin.ts
-import * as validUrl from "valid-url";
-var DownloadHttpFilePlugin = class _DownloadHttpFilePlugin {
-  apply(compiler) {
-    compiler.hooks.download.tapPromise(_DownloadHttpFilePlugin.name, async (address, task) => {
-      if (!validUrl.isUri(address)) return void 0;
-      const content = await this.download(address);
-      const spec = this.deserialize(content);
-      return JSON.stringify(spec);
-    });
+// src/plugins/initialize/initialize.plugin.ts
+import * as R22 from "ramda";
+var InitializePlugin = class _InitializePlugin {
+  constructor(options) {
+    this.options = options;
   }
-  async download(address) {
-    try {
-      const res = await fetch(address);
-      if (res.status >= 400) throw new Error(`failed with status code ${res.status}`);
-      return await res.text();
-    } catch (e) {
-      if (e instanceof Error) {
-        e.message = `Unable get the openapi/swagger file from ${address}: ${e.message}`;
+  apply(compiler) {
+    compiler.hooks.setup.tap(_InitializePlugin.name, (task) => {
+      const plugins = [
+        new DownloadHttpFilePlugin(),
+        new DownloadLocalFilePlugin()
+      ];
+      if (this.options.build) {
+        plugins.push(new ShakingPlugin());
       }
-      throw e;
+      if (this.options.interactive) {
+        plugins.push(
+          new TerminalSelectPlugin(
+            typeof this.options.interactive === "object" ? this.options.interactive : { mode: "except" }
+          )
+        );
+      }
+      const rc = compiler.context.rc;
+      plugins.push(
+        ...R22.unnest(
+          (rc.translators || []).map((translator) => {
+            const plugins2 = translator.apply();
+            return plugins2;
+          })
+        )
+      );
+      if (rc.plugins && rc.plugins.length) {
+        plugins.push(...rc.plugins);
+      }
+      for (const plugin of plugins) {
+        plugin.apply(compiler);
+      }
+    });
+    if (this.options.includes && this.options.includes.length) {
+      const modulesIncludes = this.options.includes;
+      compiler.hooks.afterSetup.tap(_InitializePlugin.name, (task) => {
+        const rc = compiler.context.rc;
+        const matcher = compiler.context.matcher;
+        const notExistModules = modulesIncludes.filter((moduleName) => !(moduleName in rc.modules));
+        if (notExistModules.length) {
+          throw new Error(`Cannot find module(s) ${notExistModules.join(", ")} in config file.`);
+        }
+        const ignoredModules = R22.difference(R22.keys(rc.modules), modulesIncludes);
+        for (const moduleName of ignoredModules) {
+          matcher.append({
+            persist: false,
+            ignore: true,
+            moduleName,
+            operationMethod: "*",
+            operationPathname: "*"
+          });
+        }
+      });
     }
   }
-  deserialize(content) {
-    const json = JSON.parse(content);
-    const spec = OpenapiUtils.to3_1(json);
-    return spec;
+};
+
+// src/plugins/overwrite-query-options/overwrite-query-options.plugin.ts
+var QsArrayFormatUnion = Object.values(QsArrayFormat);
+
+// src/translators/micro-function.translator.ts
+var MicroFunctionTranslator = class {
+  apply() {
+    return [
+      new GenerateDeclarationPlugin(),
+      new GenerateMicroFunctionPlugin()
+    ];
   }
 };
 
-// src/plugins/download-local-file/download-local-file.plugin.ts
-import * as path12 from "path";
-import * as fs5 from "fs/promises";
-import * as yaml from "js-yaml";
-var DownloadLocalFilePlugin = class _DownloadLocalFilePlugin {
-  apply(compiler) {
-    compiler.hooks.download.tapPromise(_DownloadLocalFilePlugin.name, async (address, task) => {
-      if (!address.startsWith("./") && !address.startsWith("/") && !address.startsWith("../")) return void 0;
-      const fileExt = path12.extname(address);
-      const content = await fs5.readFile(address, "utf8");
-      if ([".yml", ".yaml"].includes(fileExt)) {
-        const value = yaml.load(content);
-        return JSON.stringify(OpenapiUtils.to3_1(value));
-      } else if (fileExt === ".json") {
-        return JSON.stringify(OpenapiUtils.to3_1(JSON.parse(content)));
+// src/compiler/tasks/setup/index.ts
+var explore = cosmiconfig("keq");
+function main(compiler, options) {
+  return {
+    task: async (context, task) => {
+      const result = options?.config ? await explore.load(options.config) : await explore.search();
+      if (!result || "isEmpty" in result && result.isEmpty) {
+        throw new Error("Cannot find config file.");
+      }
+      const rc = parseRuntimeConfig(result.config);
+      if (options?.debug) {
+        await fs4.ensureDir(".keq");
+        rc.debug = true;
+      }
+      rc.tolerant = Boolean(rc.tolerant);
+      if (!rc.translators || !rc.translators.length) {
+        rc.translators = [new MicroFunctionTranslator()];
+      }
+      const packageJsonInfo = findNearestPackageJson();
+      if (packageJsonInfo) {
+        const moduleSystem = getProjectModuleSystem(packageJsonInfo);
+        rc.esm = moduleSystem === "esm";
+      }
+      context.rc = rc;
+      let matcher = new IgnoreMatcher([]);
+      if (result.filepath) {
+        const ignoreFilepath = path10.resolve(path10.dirname(result.filepath), ".keqignore");
+        if (await fs4.exists(ignoreFilepath)) {
+          matcher = await IgnoreMatcher.read(ignoreFilepath);
+        }
+      }
+      const ignoreRules = options.ignore === false ? [] : options.ignore?.rules || [];
+      for (const rule of ignoreRules) {
+        matcher.append({
+          persist: !!rule.persist,
+          ignore: rule.ignore,
+          moduleName: rule.moduleName,
+          operationMethod: rule.operationMethod,
+          operationPathname: rule.operationPathname
+        });
+      }
+      context.matcher = matcher;
+      await compiler.hooks.setup.promise(task);
+    }
+  };
+}
+function createSetupTask(compiler, options) {
+  return {
+    title: "Setup",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        main(compiler, options),
+        {
+          task: (context2, task2) => compiler.hooks.afterSetup.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
+
+// src/compiler/tasks/download/index.ts
+import { PRESET_TIMER } from "listr2";
+import { validate } from "@scalar/openapi-parser";
+function main2(compiler, options) {
+  return {
+    task: (context, task) => {
+      if (!context.rc || !context.matcher) {
+        throw new Error("Please run setup task first.");
+      }
+      const rc = context.rc;
+      const matcher = context.matcher;
+      context.documents = [];
+      return task.newListr(
+        Object.entries(rc.modules).map(([moduleName, address]) => new ModuleDefinition(moduleName, address)).map((moduleDefinition) => ({
+          title: moduleDefinition.name,
+          task: async (ctx, task2) => {
+            if (options?.skipIgnoredModules && matcher.isModuleIgnored(moduleDefinition)) {
+              task2.skip(`(${moduleDefinition.name}) is ignored`);
+              return;
+            }
+            task2.output = `Downloaded from ${moduleDefinition.address.url}`;
+            const content = await compiler.hooks.download.promise(moduleDefinition.address, moduleDefinition, task2);
+            if (!content) {
+              throw new Exception(moduleDefinition, `Cannot download document from ${moduleDefinition.address.url}`);
+            }
+            const spec = JSON.parse(content);
+            const { valid, errors } = await validate(spec);
+            if (!valid) {
+              const message = `${moduleDefinition.name} module openapi/swagger file does not conform to the openapi specifications or have grammatical errors, which may cause unexpected errors: 
+${errors?.map((e) => `  - ${e.message}`).join("\n")}`;
+              task2.output = message;
+            }
+            OpenapiUtils.dereferenceOperation(spec);
+            const document = new ApiDocumentV3_1(
+              spec,
+              moduleDefinition
+            );
+            ctx.documents?.push(document);
+          }
+        })),
+        {
+          concurrent: true,
+          exitOnError: false,
+          collectErrors: "minimal",
+          rendererOptions: {
+            collapseSubtasks: false,
+            // collapseSkips: false,
+            suffixSkips: true,
+            timer: PRESET_TIMER
+          }
+        }
+      );
+    }
+  };
+}
+function createDownloadTask(compiler, options) {
+  return {
+    title: "Download",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (_, task) => task.newListr(
+      [
+        main2(compiler, options),
+        {
+          task: (context, task2) => compiler.hooks.afterDownload.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
+
+// src/compiler/tasks/persist/index.ts
+import * as path11 from "path";
+import fs5 from "fs-extra";
+function createPersistArtifactTask() {
+  return {
+    title: "Write files",
+    task: async (context, task) => {
+      if (!context.rc) throw new Error("Please run setup task first.");
+      if (!context.artifacts || context.artifacts.length === 0) {
+        task.skip("No compiled artifacts to persist.");
+        return;
+      }
+      const rc = context.rc;
+      const artifacts = context.artifacts;
+      const total = artifacts.length;
+      let completed = 0;
+      const files = await Promise.all(artifacts.map(async (artifact) => {
+        const realpath = `./${path11.join(rc.outdir, artifact.filepath)}`;
+        await fs5.ensureFile(realpath);
+        await fs5.writeFile(realpath, artifact.renderer());
+        completed += 1;
+        task.output = `Persisted ${completed}/${total} files`;
+        return new Asset(path11.resolve(realpath));
+      }));
+      context.assets = files;
+    }
+  };
+}
+function createPersistIgnoreTask() {
+  return {
+    title: "Update .keqignore",
+    task: async (context, task) => {
+      if (!context.matcher) throw new Error("Please run setup task first.");
+      const matcher = context.matcher;
+      await matcher.write(".keqignore");
+    }
+  };
+}
+function main3() {
+  return {
+    task: (context, task) => task.newListr(
+      [
+        createPersistArtifactTask(),
+        createPersistIgnoreTask()
+      ],
+      {
+        concurrent: true,
+        rendererOptions: {
+          collapseSubtasks: true
+        }
+      }
+    )
+  };
+}
+function createPersistTask(compiler, options) {
+  return {
+    title: "Persist",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        main3(),
+        {
+          task: (context2, task2) => compiler.hooks.afterPersist.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
       }
-    });
-  }
-};
+    )
+  };
+}
 
-// src/plugins/shaking/shaking.plugin.ts
-import { openapiShakingSync } from "@opendoc/openapi-shaking";
-var ShakingPlugin = class _ShakingPlugin {
-  apply(compiler) {
-    compiler.hooks.beforeCompile.tap(_ShakingPlugin.name, (task) => {
-      const matcher = compiler.context.matcher;
-      const documents = compiler.context.documents;
-      compiler.context.documents = documents.map((document) => this.shaking(compiler, document)).filter((document) => !document.isEmpty()).filter((document) => !matcher.isModuleIgnored(document.module));
-    });
-  }
-  shaking(compiler, document) {
-    const rc = compiler.context.rc;
-    const matcher = compiler.context.matcher;
-    const isAccepted = (pathname, method, operation) => {
-      if (!SupportedMethods.includes(method)) return false;
-      return !matcher.isOperationIgnored(new OperationDefinition({
-        method,
-        pathname,
-        operation,
-        module: document.module,
-        document
-      }));
-    };
-    const sharkedSwagger = openapiShakingSync(
-      document.specification,
-      isAccepted,
-      { tolerant: rc.tolerant }
-    );
-    return new ApiDocumentV3_1(
-      sharkedSwagger,
-      new ModuleDefinition(
-        document.module.name,
-        `file://${document.module.name}.v3_1.sharked.json`
-      )
-    );
-  }
-};
+// src/compiler/tasks/compile/index.ts
+function main4(compiler) {
+  return {
+    task: async (context, task) => {
+      if (!context.rc) throw new Error("Please run setup task first.");
+      if (!context.documents) throw new Error("Please run shaking task first.");
+      context.artifacts = [];
+      await compiler.hooks.compile.promise(task);
+    }
+  };
+}
+function createCompileTask(compiler, options) {
+  return {
+    title: "Compile",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        {
+          task: (context2, task2) => compiler.hooks.beforeCompile.promise(task2)
+        },
+        main4(compiler),
+        {
+          task: (context2, task2) => compiler.hooks.afterCompile.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
 
-// src/plugins/terminal-select/utils/select-operation-definitions.ts
-import { select } from "inquirer-select-pro";
-import { ListrInquirerPromptAdapter } from "@listr2/prompt-adapter-inquirer";
-async function selectOperationDefinitions(task, operationDefinitions) {
-  const selectedOperationDefinitions = await task.prompt(ListrInquirerPromptAdapter).run(
-    select,
-    {
-      message: "Select Pathname",
-      defaultValue: [],
-      options: (input) => {
-        const items = operationDefinitions.map((op) => ({ name: `${op.module.name} ${op.method.toUpperCase()} ${op.pathname}`, value: op }));
-        if (!input) return items;
-        const keys2 = input.trim().toLowerCase().split(/\s+/);
-        return items.filter((i) => {
-          const name = i.name.toLowerCase();
-          return keys2.every((q) => name.includes(q));
-        });
+// src/compiler/intercepter/print-information.ts
+function proxyTaskWrapper(pluginName, task) {
+  return new Proxy(task, {
+    set(target, prop2, value) {
+      if (prop2 !== "output") {
+        return Reflect.set(target, prop2, value);
       }
+      target.output = `[Plugin: ${pluginName}] ${value}`;
+      return true;
     }
-  );
-  return selectedOperationDefinitions;
+  });
 }
-
-// src/plugins/terminal-select/terminal-select.plugin.ts
-var TerminalSelectPlugin = class _TerminalSelectPlugin {
-  constructor(options) {
-    this.options = options;
-  }
-  apply(compiler) {
-    compiler.hooks.afterDownload.tapPromise(_TerminalSelectPlugin.name, async (task) => {
-      const context = compiler.context;
-      const matcher = context.matcher;
-      const documents = context.documents;
-      const operationDefinitions = documents.flatMap((document) => document.operations);
-      const selectedOperationDefinitions = await selectOperationDefinitions(task, operationDefinitions);
-      if (this.options.clear) {
-        matcher.append({
-          persist: false,
-          ignore: true,
-          moduleName: "*",
-          operationMethod: "*",
-          operationPathname: "*"
-        });
+function printInformation(taskIndex) {
+  return {
+    register: (tap) => {
+      const fn = tap.fn;
+      if (tap.type === "promise") {
+        tap.fn = (...args) => {
+          const task = args[taskIndex];
+          const proxyTask = proxyTaskWrapper(tap.name, task);
+          args[taskIndex] = proxyTask;
+          proxyTask.output = "Processing...";
+          return fn(...args);
+        };
       }
-      for (const op of selectedOperationDefinitions) {
-        matcher.append({
-          persist: !!this.options.persist,
-          ignore: this.options.mode === "add",
-          moduleName: op.module.name,
-          operationMethod: op.method,
-          operationPathname: op.pathname
-        });
+      if (tap.type === "sync") {
+        tap.fn = (...args) => {
+          const task = args[taskIndex];
+          const proxyTask = proxyTaskWrapper(tap.name, task);
+          args[taskIndex] = proxyTask;
+          proxyTask.output = "Processing...";
+          return fn(...args);
+        };
       }
-    });
-  }
-};
+      if (tap.type === "async") {
+        tap.fn = (...args) => {
+          const task = args[taskIndex];
+          const proxyTask = proxyTaskWrapper(tap.name, task);
+          args[taskIndex] = proxyTask;
+          proxyTask.output = "Processing...";
+          return fn(...args);
+        };
+      }
+      return tap;
+    }
+  };
+}
 
-// src/plugins/initialize/initialize.plugin.ts
+// src/compiler/intercepter/perfect-error-message.ts
 import * as R23 from "ramda";
-var InitializePlugin = class _InitializePlugin {
-  constructor(options) {
-    this.options = options;
-  }
-  apply(compiler) {
-    compiler.hooks.setup.tap(_InitializePlugin.name, (task) => {
-      new DownloadHttpFilePlugin().apply(compiler);
-      new DownloadLocalFilePlugin().apply(compiler);
-      new GenerateDeclarationPlugin().apply(compiler);
-      if (this.options.build) {
-        new ShakingPlugin().apply(compiler);
-      }
-      if (this.options.interactive) {
-        new TerminalSelectPlugin(
-          typeof this.options.interactive === "object" ? this.options.interactive : { mode: "except" }
-        ).apply(compiler);
+function perfectErrorMessage() {
+  return {
+    register: (tap) => {
+      const fn = tap.fn;
+      function prefix(err) {
+        if (err instanceof Error) {
+          err.message = `[Plugin: ${tap.name}] ${err.message}`;
+        }
       }
-      const rc = compiler.context.rc;
-      if (rc.mode === "micro-function") {
-        new GenerateMicroFunctionPlugin().apply(compiler);
-      } else if (rc.mode === "nestjs-module") {
-        new GenerateNestjsModulePlugin().apply(compiler);
+      if (tap.type === "promise") {
+        tap.fn = async (...args) => {
+          try {
+            return await fn(...args);
+          } catch (err) {
+            prefix(err);
+            throw err;
+          }
+        };
       }
-      if (rc.plugins && rc.plugins.length) {
-        for (const plugin of rc.plugins) {
-          plugin.apply(compiler);
-        }
+      if (tap.type === "sync") {
+        tap.fn = (...args) => {
+          try {
+            return fn(...args);
+          } catch (err) {
+            prefix(err);
+            throw err;
+          }
+        };
       }
-    });
-    if (this.options.includes && this.options.includes.length) {
-      const modulesIncludes = this.options.includes;
-      compiler.hooks.afterSetup.tap(_InitializePlugin.name, (task) => {
-        const rc = compiler.context.rc;
-        const matcher = compiler.context.matcher;
-        const notExistModules = modulesIncludes.filter((moduleName) => !(moduleName in rc.modules));
-        if (notExistModules.length) {
-          throw new Error(`Cannot find module(s) ${notExistModules.join(", ")} in config file.`);
-        }
-        const ignoredModules = R23.difference(R23.keys(rc.modules), modulesIncludes);
-        for (const moduleName of ignoredModules) {
-          matcher.append({
-            persist: false,
-            ignore: true,
-            moduleName,
-            operationMethod: "*",
-            operationPathname: "*"
+      if (tap.type === "async") {
+        tap.fn = (...args) => {
+          const callback = R23.last(args);
+          return fn(...R23.init(args), (err, result) => {
+            prefix(err);
+            return callback(err, result);
           });
-        }
-      });
+        };
+      }
+      return tap;
     }
-  }
-};
-
-// src/plugins/overwrite-query-options/overwrite-query-options.plugin.ts
-var QsArrayFormatUnion = Object.values(QsArrayFormat);
+  };
+}
 
 // src/compiler/compiler.ts
 var Compiler = class {