wormajs 0.2.5 → 0.2.7

package/README.md

@@ -85,8 +85,8 @@ Effective contributions will win you a certain reputation in the worma community
 
 ## Contributors
 
-<a href="https://github.com/alovajs/alova/graphs/contributors">
-<img src="https://contrib.rocks/image?repo=alovajs/alova&max=30&columns=10" />
+<a href="https://github.com/alovajs/devtools/graphs/contributors">
+<img src="https://contrib.rocks/image?repo=alovajs/devtools&max=30&columns=10" />
 </a>
 
 ## LICENSE

package/dist/constant.js

@@ -1,18 +1,18 @@
 "use strict";
 // ============================================================
-// 枚举常量定义 — 统一管理项目中所有硬编码的字符串/数字常量
+// Enumeration constant definitions — centrally manage all hardcoded string/number constants in the project
 // ============================================================
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FRAMEWORK_NAMES = exports.MODULE_TYPE_TO_KIND = exports.MODULE_TYPE_DIRS = exports.ModuleTypeDir = exports.PresetTemplateName = exports.TemplateSkipDir = exports.TemplatePlaceholder = exports.PluginName = exports.FilterScope = exports.RenameScope = exports.ParameterIn = exports.TEMPLATE_EXTENSIONS = exports.FileExtension = exports.FrameworkName = exports.ModuleKind = exports.PlatformTypeEnum = exports.ConfigTypeEnum = exports.TemplateTypeEnum = void 0;
 exports.getTypeFileExtension = getTypeFileExtension;
-/** 模板代码生成类型 */
+/** Template code generation type */
 var TemplateTypeEnum;
 (function (TemplateTypeEnum) {
     TemplateTypeEnum["TYPESCRIPT"] = "typescript";
     TemplateTypeEnum["MODULE"] = "module";
     TemplateTypeEnum["COMMONJS"] = "commonjs";
 })(TemplateTypeEnum || (exports.TemplateTypeEnum = TemplateTypeEnum = {}));
-/** 配置中的 type 字段值（比 TemplateTypeEnum 多了 auto/ts 选项） */
+/** The type field value in config (adds auto/ts options over TemplateTypeEnum) */
 var ConfigTypeEnum;
 (function (ConfigTypeEnum) {
     ConfigTypeEnum["AUTO"] = "auto";
@@ -21,7 +21,7 @@ var ConfigTypeEnum;
     ConfigTypeEnum["MODULE"] = "module";
     ConfigTypeEnum["COMMONJS"] = "commonjs";
 })(ConfigTypeEnum || (exports.ConfigTypeEnum = ConfigTypeEnum = {}));
-/** 支持的 OpenAPI 平台 */
+/** Supported OpenAPI platforms */
 var PlatformTypeEnum;
 (function (PlatformTypeEnum) {
     PlatformTypeEnum["SWAGGER"] = "swagger";
@@ -29,13 +29,13 @@ var PlatformTypeEnum;
     PlatformTypeEnum["FASTAPI"] = "fastapi";
     PlatformTypeEnum["YAPI"] = "yapi";
 })(PlatformTypeEnum || (exports.PlatformTypeEnum = PlatformTypeEnum = {}));
-/** 模块体系类型 */
+/** Module system type */
 var ModuleKind;
 (function (ModuleKind) {
     ModuleKind["ES_MODULE"] = "ESModule";
     ModuleKind["COMMON_JS"] = "commonJs";
 })(ModuleKind || (exports.ModuleKind = ModuleKind = {}));
-/** 前端框架名称 */
+/** Frontend framework names */
 var FrameworkName;
 (function (FrameworkName) {
     FrameworkName["VUE"] = "vue";
@@ -44,7 +44,7 @@ var FrameworkName;
     FrameworkName["SOLID_JS"] = "solid-js";
     FrameworkName["NUXT"] = "nuxt";
 })(FrameworkName || (exports.FrameworkName = FrameworkName = {}));
-/** 模板文件扩展名 */
+/** Template file extensions */
 var FileExtension;
 (function (FileExtension) {
     FileExtension["HBS"] = ".hbs";
@@ -59,9 +59,9 @@ var FileExtension;
     FileExtension["D_CTS"] = ".d.cts";
     FileExtension["D_MTS"] = ".d.mts";
 })(FileExtension || (exports.FileExtension = FileExtension = {}));
-/** Handlebars 模板文件扩展名列表（不含普通 ts/js 扩展） */
+/** List of Handlebars template file extensions (excluding plain ts/js extensions) */
 exports.TEMPLATE_EXTENSIONS = Object.values(FileExtension);
-/** OpenAPI 参数位置 */
+/** OpenAPI parameter locations */
 var ParameterIn;
 (function (ParameterIn) {
     ParameterIn["QUERY"] = "query";
@@ -69,7 +69,7 @@ var ParameterIn;
     ParameterIn["HEADER"] = "header";
     ParameterIn["COOKIE"] = "cookie";
 })(ParameterIn || (exports.ParameterIn = ParameterIn = {}));
-/** 重命名的 scope 类型 */
+/** Rename scope types */
 var RenameScope;
 (function (RenameScope) {
     RenameScope["URL"] = "url";
@@ -80,13 +80,13 @@ var RenameScope;
     RenameScope["REF_NAME"] = "refName";
     RenameScope["NAME"] = "name";
 })(RenameScope || (exports.RenameScope = RenameScope = {}));
-/** 过滤 scope 类型 */
+/** Filter scope types */
 var FilterScope;
 (function (FilterScope) {
     FilterScope["URL"] = "url";
     FilterScope["TAG"] = "tag";
 })(FilterScope || (exports.FilterScope = FilterScope = {}));
-/** 内建插件名称 */
+/** Built-in plugin names */
 var PluginName;
 (function (PluginName) {
     PluginName["TAG_MODIFIER"] = "tagModifier";
@@ -107,19 +107,19 @@ var PluginName;
     PluginName["TEMPLATE_KY"] = "templateKy";
     PluginName["TEMPLATE_CONFIG"] = "templateConfig";
 })(PluginName || (exports.PluginName = PluginName = {}));
-/** 模板占位符 */
+/** Template placeholders */
 var TemplatePlaceholder;
 (function (TemplatePlaceholder) {
     TemplatePlaceholder["TAG"] = "{tag}";
     TemplatePlaceholder["API"] = "{api}";
 })(TemplatePlaceholder || (exports.TemplatePlaceholder = TemplatePlaceholder = {}));
-/** 模板扫描时跳过的目录 */
+/** Directories skipped during template scanning */
 var TemplateSkipDir;
 (function (TemplateSkipDir) {
     TemplateSkipDir["PARTIALS"] = "partials";
     TemplateSkipDir["TAG_DIR"] = "{tag}";
 })(TemplateSkipDir || (exports.TemplateSkipDir = TemplateSkipDir = {}));
-/** 预设模板名称 */
+/** Preset template names */
 var PresetTemplateName;
 (function (PresetTemplateName) {
     PresetTemplateName["ALOVA"] = "alova";
@@ -130,26 +130,26 @@ var PresetTemplateName;
     PresetTemplateName["CONFIG"] = "config";
     PresetTemplateName["AI_DOC"] = "ai-doc";
 })(PresetTemplateName || (exports.PresetTemplateName = PresetTemplateName = {}));
-/** 模板目录名（与 config.type 不同：commonjs -> common） */
+/** Template directory name (differs from config.type: commonjs -> common) */
 var ModuleTypeDir;
 (function (ModuleTypeDir) {
     ModuleTypeDir["TYPESCRIPT"] = "typescript";
     ModuleTypeDir["MODULE"] = "module";
     ModuleTypeDir["COMMON"] = "common";
 })(ModuleTypeDir || (exports.ModuleTypeDir = ModuleTypeDir = {}));
-/** 模块类型目录名数组 */
+/** Array of module-type directory names */
 exports.MODULE_TYPE_DIRS = [ModuleTypeDir.TYPESCRIPT, ModuleTypeDir.MODULE, ModuleTypeDir.COMMON];
-/** 模块类型 -> ModuleKind 映射 */
+/** Module type -> ModuleKind mapping */
 exports.MODULE_TYPE_TO_KIND = {
     [TemplateTypeEnum.TYPESCRIPT]: ModuleKind.ES_MODULE,
     [TemplateTypeEnum.MODULE]: ModuleKind.ES_MODULE,
     [TemplateTypeEnum.COMMONJS]: ModuleKind.COMMON_JS,
 };
-/** 文件扩展名 -> 输出文件名映射 */
+/** File extension -> output file name mapping */
 function getTypeFileExtension(type) {
     return type === TemplateTypeEnum.TYPESCRIPT ? FileExtension.TS : FileExtension.JS;
 }
-/** 框架名称列表 */
+/** Framework name list */
 exports.FRAMEWORK_NAMES = [
     FrameworkName.VUE,
     FrameworkName.REACT,

package/dist/core/loader/astLoader/generates/tuple.js

@@ -16,7 +16,7 @@ function tupleTypeGenerator(ast, ctx) {
     const spreadParam = ast.spreadParam ?? {
         type: type_1.ASTType.ANY,
     };
-    // 封闭元组（禁止额外项）时不展开剩余项
+    // for closed tuples (no extra items allowed), do not spread the rest param
     const isClosed = spreadParam.type === type_1.ASTType.NEVER;
     if (!isClosed) {
         while (params.length < minItems) {

package/dist/core/loader/astLoader/normalize/index.js

@@ -15,7 +15,7 @@ const removeRedundantKeywords_1 = __importDefault(require("./rules/removeRedunda
 const simplifySingleType_1 = __importDefault(require("./rules/simplifySingleType"));
 const validateSchema_1 = __importDefault(require("./rules/validateSchema"));
 const normalizer = new normalizer_1.SchemaNormalizer();
-// ================= 注册规则 =================
+// ================= Register rules =================
 normalizer
     .addRule({
     name: 'inferType',

package/dist/core/loader/astLoader/normalize/normalizer.js

@@ -6,25 +6,25 @@ const utils_1 = require("../../../../utils");
 class SchemaNormalizer {
     rules = [];
     /**
-     * 添加新规则
+     * Add a new rule
      */
     addRule(rule) {
         this.rules.push(rule);
         return this;
     }
     /**
-     * 规范化 JSON Schema
-     * M1-A3: 循环检测从 JSON.stringify 改为 WeakSet，消除每节点 O(s) 序列化开销
+     * Normalize JSON Schema
+     * M1-A3: replaced JSON.stringify-based cycle detection with WeakSet, eliminating the O(s) serialization cost per node
      */
     normalize(schema) {
-        // 深度优先遍历
+        // depth-first traversal
         const visited = new WeakSet();
         const process = (s) => {
             if (!s || (0, utils_1.isReferenceObject)(s) || visited.has(s)) {
                 return s;
             }
             visited.add(s);
-            // 处理组合模式
+            // process combinatory keywords
             if (s.anyOf) {
                 s.anyOf = s.anyOf.map(item => process(item));
             }
@@ -34,11 +34,11 @@ class SchemaNormalizer {
             if (s.allOf) {
                 s.allOf = s.allOf.map(item => process(item));
             }
-            // 处理数组类型
+            // process array type
             if ((0, utils_1.isMaybeArraySchemaObject)(s)) {
                 s.items = process(s.items);
             }
-            // 处理对象属性
+            // process object properties
             if (s.properties) {
                 const newProps = {};
                 for (const [key, value] of Object.entries(s.properties)) {
@@ -47,7 +47,7 @@ class SchemaNormalizer {
                 s.properties = newProps;
             }
             let result = s;
-            // 应用规则
+            // apply rules
             for (const rule of this.rules) {
                 const newResult = rule.handler(result);
                 if (newResult && !visited.has(newResult)) {

package/dist/core/loader/astLoader/normalize/rules/mergeAnyOf.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = mergeAnyOf;
 /**
- * 检测两个 schema 在某个共享属性上是否构成判别式。
- * 当不同分支对同一字段使用不同的 const 或 enum 时，合并这些分支会
- * 丢掉判别信息，因此应保留为独立的联合分支。
+ * Detect whether two schemas form a discriminator on a shared property.
+ * When different branches use different const or enum values for the same field,
+ * merging them would lose the discriminant information, so they should be kept
+ * as separate union branches.
  */
 function hasDiscriminatorConflict(a, b) {
     const aProps = (a.properties ?? {});
@@ -15,15 +16,15 @@ function hasDiscriminatorConflict(a, b) {
         }
         const ap = aProps[key];
         const bp = bProps[key];
-        // 不同的 const 值 → 判别式
+        // different const values -> discriminator
         if (ap.const !== undefined && bp.const !== undefined && ap.const !== bp.const) {
             return true;
         }
-        // 一个 const、一个 enum → 判别式
+        // one const, one enum -> discriminator
         if ((ap.const !== undefined && bp.enum) || (bp.const !== undefined && ap.enum)) {
             return true;
         }
-        // 不同的 enum 值 → 判别式
+        // different enum values -> discriminator
         if (ap.enum && bp.enum) {
             const aKey = JSON.stringify([...ap.enum].sort());
             const bKey = JSON.stringify([...bp.enum].sort());
@@ -35,7 +36,7 @@ function hasDiscriminatorConflict(a, b) {
     return false;
 }
 /**
- * 组内任意两个分支存在判别式冲突即视为有冲突。
+ * A group is considered to have a conflict if any two of its branches have a discriminator conflict.
  */
 function groupHasDiscriminatorConflict(group) {
     for (let i = 0; i < group.length; i++) {
@@ -65,7 +66,7 @@ function mergeAnyOf(schema) {
             mergedAnyOf.push(group[0]);
             continue;
         }
-        // 组内分支之间只要存在判别式冲突，就保留原始分支不做合并
+        // if any discriminator conflict exists within the group, keep the original branches unmerged
         if (groupHasDiscriminatorConflict(group)) {
             mergedAnyOf.push(...group);
             continue;

package/dist/core/loader/astLoader/normalize/rules/normalizeCombiningKeywords.js

@@ -3,24 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = normalizeCombiningKeywords;
 function normalizeCombiningKeywords(schema) {
     const { allOf, anyOf, oneOf, ...baseSchema } = schema;
-    // 如果没有组合关键字，或只存在其中一个，则无需处理
+    // if there are no combinatory keywords, or only one of them exists, no processing is needed
     if ([allOf, anyOf, oneOf].filter(Boolean).length <= 1) {
         return;
     }
-    // 用于存储最终转换后的 allOf 数组
+    // store the final converted allOf array
     const allOfArray = [];
-    // 2. 处理原始 allOf（展开到新 allOf 中）
+    // 2. process the original allOf (spread into the new allOf)
     if (Array.isArray(allOf)) {
         allOfArray.push(...allOf);
     }
-    // 3. 处理 anyOf（包装成 anyOf 对象）
+    // 3. process anyOf (wrap into an anyOf object)
     if (Array.isArray(anyOf) && anyOf.length > 0) {
         allOfArray.push({ anyOf });
     }
-    // 4. 处理 oneOf（包装成 oneOf 对象）
+    // 4. process oneOf (wrap into a oneOf object)
     if (Array.isArray(oneOf) && oneOf.length > 0) {
         allOfArray.push({ oneOf });
     }
-    // 构建最终模式
+    // build the final schema
     return allOfArray.length > 0 ? { allOf: allOfArray, ...baseSchema } : baseSchema;
 }

package/dist/core/loader/astLoader/normalize/rules/normalizeNullType.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = normalizeNullType;
 const NULL_TYPE = [null, 'null'];
 function normalizeNullType(schema) {
-    // 兼容openai3.0的nullable
+    // compatible with OpenAPI 3.0 nullable
     if (schema.nullable) {
         delete schema.nullable;
         const currentType = schema.type || [];

package/dist/core/loader/astLoader/parsers/const.js

@@ -4,15 +4,15 @@ exports.constTypeParser = constTypeParser;
 const type_1 = require("../../../../type");
 const utils_1 = require("./utils");
 /**
- * 将带有 const 关键字的 JSON Schema 解析为字面量 AST 节点。
- * 例如：
+ * Parse a JSON Schema with a const keyword into a literal AST node.
+ * For example:
  *   { "type": "string", "const": "email" }   -> "email"
  *   { "type": "number", "const": 1 }          -> 1
  *   { "const": true }                         -> true
  *   { "const": "authorization_code" }         -> "authorization_code"
  *
- * 参考：JSON Schema draft-04+ 允许 `const` 与 `type` 同时出现，
- * 表示该字段必须等于 `const` 的值，对应到 TypeScript 即字面量类型。
+ * Reference: JSON Schema draft-04+ allows `const` and `type` to appear together,
+ * meaning the field must equal the `const` value, which maps to a TypeScript literal type.
  */
 function constTypeParser(schema, ctx) {
     const result = {

package/dist/core/loader/astLoader/parsers/enum.js

@@ -14,16 +14,16 @@ function enumTypeParser(schema, ctx) {
     };
     const enumArray = schema.enum ?? [];
     let typeArray = [schema.type ?? []].flat();
-    // 如果没有指定type，从enum值中推断类型
+    // if type is not specified, infer it from the enum values
     if (typeArray.length === 0 && enumArray.length > 0) {
         typeArray = [...new Set(enumArray.map(item => (0, utils_1.getType)(item)))];
     }
-    // 类型兼容性检查函数
+    // type compatibility check function
     const isTypeCompatible = (itemType, allowedTypes) => {
         return allowedTypes.includes(itemType)
             || (allowedTypes.includes('number') && itemType === 'integer');
     };
-    // 验证所有枚举值的类型
+    // validate the type of all enum values
     const hasInvalidType = enumArray.some(item => !isTypeCompatible((0, utils_1.getType)(item), typeArray));
     if (hasInvalidType) {
         throw helper_1.logger.throwError(`enum ${schema.title ?? 'undefined'} type error`, {

package/dist/core/loader/astLoader/parsers/forward/array.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../../../../../utils");
 exports.default = {
     is(schema) {
-        // 判断是否为数组类型
-        // 1. type 为 'array'
-        // 2. 或者有 items 字段
+        // check whether it is an array type
+        // 1. type is 'array'
+        // 2. or has an items field
         return schema && (schema.type === 'array' || (0, utils_1.isMaybeArraySchemaObject)(schema));
     },
     to: 'array',

package/dist/core/loader/astLoader/parsers/forward/const.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * 带有 const 关键字的 schema 优先路由到 const 解析器，
- * 即使 schema 同时声明了 type（如 `{ "type": "string", "const": "email" }`），
- * 也能正确产出字面量类型。
+ * Schemas with a const keyword are routed to the const parser first.
+ * This works even when the schema also declares a type (e.g. `{ "type": "string", "const": "email" }`),
+ * producing the correct literal type.
  */
 exports.default = {
     is(schema) {

package/dist/core/loader/astLoader/parsers/forward/enum.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     is(schema) {
-        // 判断是否为枚举类型
-        // 有 enum 字段且不为空数组
+        // check whether it is an enum type
+        // has an enum field that is a non-empty array
         return schema && !!schema.enum && Array.isArray(schema.enum) && schema.enum.length > 0;
     },
     to: 'enum',

package/dist/core/loader/astLoader/parsers/forward/group.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     is(schema) {
-        // 判断是否为组合类型
-        // 1. 有 oneOf 字段（联合类型）
-        // 2. 或者有 anyOf 字段（联合类型）
-        // 3. 或者有 allOf 字段（交叉类型）
+        // check whether it is a combinatory type
+        // 1. has oneOf field (union type)
+        // 2. or has anyOf field (union type)
+        // 3. or has allOf field (intersection type)
         return schema && (!!schema.oneOf || !!schema.anyOf || !!schema.allOf);
     },
     to: 'group',

package/dist/core/loader/astLoader/parsers/forward/object.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     is(schema) {
-        // 判断是否为对象类型
-        // 1. type 为 'object'
-        // 2. 或者有 properties 字段
-        // 3. 或者有 additionalProperties 字段
+        // check whether it is an object type
+        // 1. type is 'object'
+        // 2. or has a properties field
+        // 3. or has an additionalProperties field
         return schema && (schema.type === 'object' || !!schema.properties || !!schema.additionalProperties);
     },
     to: 'object',

package/dist/core/loader/astLoader/parsers/forward/tuple.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     is(schema) {
-        // 判断是否为元组类型
-        // 1. type 为 'array'
-        // 2. 且 items 是数组（老版 JSON Schema 元组语法）或存在 prefixItems（OpenAPI 3.1 / JSON Schema 2020-12 元组语法）
+        // check whether it is a tuple type
+        // 1. type is 'array'
+        // 2. items is an array (legacy JSON Schema tuple syntax) or prefixItems exists (OpenAPI 3.1 / JSON Schema 2020-12 tuple syntax)
         if (!schema)
             return false;
         const tuple = schema;

package/dist/core/loader/astLoader/parsers/group.js

@@ -33,7 +33,7 @@ function groupTypeParser(schema, ctx) {
         };
     }
     if (schema.allOf) {
-        // 显式检查 allOf
+        // explicitly check allOf
         return {
             ...result,
             type: type_1.ASTType.INTERSECTION,

package/dist/core/loader/astLoader/parsers/tuple.js

@@ -5,12 +5,12 @@ const helper_1 = require("../../../../helper");
 const type_1 = require("../../../../type");
 const utils_1 = require("./utils");
 function tupleTypeParser(schema, ctx) {
-    // OpenAPI 3.1 / JSON Schema 2020-12 用 prefixItems 表示固定位置元素，兼容老版 items 数组写法
+    // OpenAPI 3.1 / JSON Schema 2020-12 uses prefixItems for positional elements, with legacy array-style items supported
     const elementSchemas = (Array.isArray(schema.prefixItems)
         ? schema.prefixItems
         : (Array.isArray(schema.items) ? schema.items : []));
     const params = elementSchemas.map(item => ctx.next(item, ctx.options));
-    // 2020-12：单数 items 表示"剩余项"类型；items:false / additionalItems:false 表示禁止额外项
+    // 2020-12: a single items denotes the "rest items" type; items:false / additionalItems:false forbids extra items
     let spreadParam;
     if (schema.items && !Array.isArray(schema.items)) {
         spreadParam = ctx.next(schema.items, ctx.options);

package/dist/core/loader/standardLoader/helper.js

@@ -78,7 +78,7 @@ function splitIntoWords(str) {
         const char = str[i];
         const lastChar = str[i - 1] ?? '';
         const nextChar = str[i + 1] ?? '';
-        // 如果遇到非单词字符，结束当前单词
+        // if a non-word character is encountered, end the current word
         if (/[^\w$]/.test(char) || ['_'].includes(char)) {
             if (currentWord) {
                 words.push(currentWord);

package/dist/core/parser/templateParser/helper.js

@@ -115,13 +115,13 @@ async function parseRequestBody(requestBody, options) {
 }
 function getContentKey(content = {}, requireKey = 'application/json') {
     const requireKeys = Array.isArray(requireKey) ? requireKey : [requireKey];
-    // 按数组顺序依次查找存在的 mediaType
+    // search for an existing mediaType in array order
     for (const key of requireKeys) {
         if (content[key]) {
             return key;
         }
     }
-    // 如果都不存在，返回第一个 key 或默认值
+    // if none exists, return the first key or the default value
     return Object.keys(content)[0] || requireKeys[0];
 }
 async function parseParameters(parameters, options) {
@@ -213,7 +213,7 @@ async function transformApiMethods(apiMethod, options) {
         return apiMethod;
     }
     const { apiDescriptor, apiInfo } = apiMethod2ApiDescriptor(apiMethod, options);
-    // M2-B1: apiDescriptor 来自 apiMethod2ApiDescriptor 已做过 cloneDeep，无需二次克隆
+    // M2-B1: apiDescriptor comes from apiMethod2ApiDescriptor which already did cloneDeep, no second clone needed
     let newApiDescriptor = apiDescriptor;
     try {
         newApiDescriptor = handleApi(newApiDescriptor);
@@ -241,7 +241,7 @@ async function transformApiMethods(apiMethod, options) {
 function apiMethod2ApiDescriptor(apiMethod, options) {
     const { url, method } = apiMethod;
     const { document, config } = options;
-    // 需要深拷贝：handleApi 可能修改 tags/security 等嵌套字段，浅拷贝会污染原始 operationObject
+    // deep copy required: handleApi may mutate nested fields like tags/security; a shallow copy would pollute the original operationObject
     const operationObject = (0, lodash_1.cloneDeep)(apiMethod.operationObject);
     const { requestBody, responses, parameters } = operationObject;
     const apiDescriptor = {
@@ -292,7 +292,7 @@ function apiMethod2ApiDescriptor(apiMethod, options) {
 }
 function apiDescriptor2apiMethod(apiDescriptor, options) {
     const apiDescriptorValue = { ...apiDescriptor };
-    const operationObject = (0, lodash_1.cloneDeep)(options.operationObject); // 仍需深拷贝：content[key].schema 等深路径赋值后通过 mergeObject 回写
+    const operationObject = (0, lodash_1.cloneDeep)(options.operationObject); // still needs deep copy: deep-path assignments like content[key].schema are written back via mergeObject
     const { url, method } = apiDescriptorValue;
     const { successKey, requestKey, responseKey, hasResponse, hasParameters, hasRequestBody, requestBody, response } = options.oldApiInfo;
     if (!(0, lodash_1.isEmpty)(apiDescriptorValue.requestBody) || hasRequestBody) {

package/dist/core/parser/templateParser/index.js

@@ -47,7 +47,7 @@ const helper_1 = require("../../../helper");
 const document_1 = require("../../../helper/document");
 const openapi_1 = require("../../../utils/openapi");
 const helper_2 = require("./helper");
-/** M2-B4: 轻量并发 limiter，无额外依赖 */
+/** M2-B4: lightweight concurrency limiter, no extra dependencies */
 async function pMap(items, fn, concurrency) {
     const results = Array.from({ length: items.length });
     let idx = 0;
@@ -60,7 +60,7 @@ async function pMap(items, fn, concurrency) {
     await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
     return results;
 }
-/** 根据 CPU 核数自动计算合理并发上限 */
+/** Automatically compute a reasonable concurrency limit based on CPU core count */
 function autoConcurrency() {
     const cpuCount = Math.max(1, (0, node_os_1.cpus)().length);
     return Math.min(64, Math.max(8, cpuCount * 4));
@@ -71,7 +71,7 @@ class TemplateParser {
     operationIdSet = new Set();
     pathMap = [];
     refNameMap = new Map();
-    /** M1-A4: 用 Map 索引替代 tagedApis.find() 线性查找，O(n·t) → O(n+t) */
+    /** M1-A4: replaced tagedApis.find() linear lookup with a Map index, O(n·t) → O(n+t) */
     tagMap = new Map();
     document;
     options;
@@ -146,9 +146,11 @@ class TemplateParser {
                 const tsWp = node_path_1.default.resolve(__dirname, '../../workerPool/worker.ts');
                 const { existsSync: fex } = await Promise.resolve().then(() => __importStar(require('node:fs')));
                 const workerScript = fex(jsWp) ? jsWp : tsWp;
-                // P2: Reuse worker pool via PoolManager singleton — avoids create/destroy overhead across repeated generate() calls
+                // Reuse workers only within the same generator output. The workerData document is immutable after spawn,
+                // so generators in the same project must not share a pool.
+                const outputDir = node_path_1.default.resolve(this.options.projectPath, this.options.generatorConfig.output);
                 const pool = poolManager_1.PoolManager.getInstance().get({
-                    key: `schemaWorker_${this.options.projectPath}`,
+                    key: `schemaWorker_${outputDir}`,
                     workerScript,
                     sharedContext: {
                         document: this.document,
@@ -173,7 +175,7 @@ class TemplateParser {
         });
         templateData.components = [...new Set(this.schemasMap.values())];
         templateData.componentNames = [...this.schemasMap.keys()];
-        // 按名称字典序排序，确保输出顺序确定性（避免并发场景下 Map 插入顺序漂移）
+        // sort by name lexicographically to ensure deterministic output order (avoid Map insertion-order drift under concurrency)
         const sorted = [...this.schemasMap.entries()].sort(([a], [b]) => a.localeCompare(b));
         templateData.componentNames = sorted.map(([k]) => k);
         templateData.components = sorted.map(([, v]) => v);
@@ -301,7 +303,7 @@ class TemplateParser {
         let tagApis = this.tagMap.get(api.tag);
         if (!tagApis) {
             tagApis = {
-                tagName: api.tag,
+                tag: api.tag,
                 apis: [],
             };
             this.tagMap.set(api.tag, tagApis);

package/dist/functions/wormaJson.js

@@ -77,10 +77,10 @@ function computePerTagHashes(allApis, tagedApis) {
     const allHashes = [];
     if (tagedApis) {
         // P2: Use pre-grouped tagedApis to avoid O(n) re-grouping loop
-        for (const { tagName, apis: groupApis } of tagedApis) {
+        for (const { tag, apis: groupApis } of tagedApis) {
             const hashes = groupApis.map(computeApiHash).sort();
             allHashes.push(...hashes);
-            tags[tagName] = (0, node_crypto_1.createHash)('sha256').update(hashes.join('')).digest('hex').slice(0, 16);
+            tags[tag] = (0, node_crypto_1.createHash)('sha256').update(hashes.join('')).digest('hex').slice(0, 16);
         }
     }
     else {