@4399ywkf/core 5.0.27 → 5.0.28

package/dist/cli/index.js

@@ -2,20 +2,2136 @@
 
 // src/cli/index.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname3, join as join7 } from "path";
+import { dirname as dirname3, join as join14 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import chalk4 from "chalk";
 import { Command } from "commander";
 
 // src/cli/build.ts
-import { rspack as rspack3 } from "@rspack/core";
+import { rspack as rspack4 } from "@rspack/core";
 import chalk2 from "chalk";
 
-// src/config/loader.ts
-import { existsSync } from "fs";
-import { extname, resolve } from "path";
-import { pathToFileURL } from "url";
-import deepmerge from "deepmerge";
+// src/config/loader.ts
+import { existsSync as existsSync7 } from "fs";
+import { extname, resolve as resolve2 } from "path";
+import { pathToFileURL } from "url";
+import deepmerge from "deepmerge";
+
+// src/plugin/define.ts
+function createPlugin(factory) {
+  return factory;
+}
+
+// src/plugin/builtin/analytics.ts
+var analyticsPlugin = createPlugin((options = {}) => ({
+  name: "@4399ywkf/plugin-analytics",
+  version: "1.0.0",
+  description: "\u6784\u5EFA\u5206\u6790\u63D2\u4EF6",
+  setup(context) {
+    const {
+      buildAnalysis = true,
+      timing = true,
+      bundleSize = true,
+      sizeWarningThreshold = 500
+    } = options;
+    const { logger, isProd } = context;
+    let buildStartTime;
+    const hooks = {
+      beforeBuild() {
+        if (timing) {
+          buildStartTime = Date.now();
+          logger.info("\u5F00\u59CB\u6784\u5EFA...");
+        }
+      },
+      afterBuild(_context, stats) {
+        if (timing) {
+          const duration = Date.now() - buildStartTime;
+          logger.info(`\u6784\u5EFA\u5B8C\u6210\uFF0C\u8017\u65F6: ${(duration / 1e3).toFixed(2)}s`);
+        }
+        if (!stats.success && stats.errors) {
+          logger.error(`\u6784\u5EFA\u5931\u8D25\uFF0C\u9519\u8BEF\u6570: ${stats.errors.length}`);
+        }
+      },
+      modifyRspackConfig(config) {
+        if (buildAnalysis && isProd) {
+          logger.info("\u6784\u5EFA\u5206\u6790\u5DF2\u542F\u7528");
+        }
+        return config;
+      }
+    };
+    return hooks;
+  }
+}));
+
+// src/plugin/builtin/biome.ts
+import { existsSync, writeFileSync } from "fs";
+import { join } from "path";
+var biomePlugin = createPlugin((options = {}) => ({
+  name: "@4399ywkf/plugin-biome",
+  version: "1.0.0",
+  description: "Biome \u4EE3\u7801\u89C4\u8303\u96C6\u6210",
+  setup(context) {
+    const {
+      scaffold = true,
+      ignore = [],
+      rules: customRules,
+      formatter: customFormatter,
+      javascript: customJavascript
+    } = options;
+    const { cwd, logger } = context;
+    if (scaffold) {
+      const biomeConfigPath = join(cwd, "biome.json");
+      if (!existsSync(biomeConfigPath)) {
+        const config = buildBiomeConfig({ ignore, customRules, customFormatter, customJavascript });
+        writeFileSync(biomeConfigPath, `${JSON.stringify(config, null, 2)}
+`, "utf-8");
+        logger.info("\u5DF2\u751F\u6210 biome.json\uFF08\u7EE7\u627F @4399ywkf/core/biome\uFF09");
+      }
+    }
+    const hooks = {
+      modifyRspackConfig(rspackConfig) {
+        logger.info("Biome \u4EE3\u7801\u89C4\u8303\u5DF2\u542F\u7528");
+        return rspackConfig;
+      }
+    };
+    return hooks;
+  }
+}));
+function buildBiomeConfig(params) {
+  const { ignore, customRules, customFormatter, customJavascript } = params;
+  const config = {
+    $schema: "https://biomejs.dev/schemas/2.3.2/schema.json",
+    extends: ["@4399ywkf/core/biome"]
+  };
+  if (customFormatter) {
+    config.formatter = customFormatter;
+  }
+  if (customJavascript) {
+    config.javascript = customJavascript;
+  }
+  if (customRules && Object.keys(customRules).length > 0) {
+    config.linter = { rules: customRules };
+  }
+  if (ignore.length > 0) {
+    config.files = {
+      includes: ["**", ...ignore.map((p) => `!${p}`)]
+    };
+  }
+  return config;
+}
+
+// src/plugin/builtin/browser-check.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join2 } from "path";
+var DEFAULT_FEATURES = ["Object.hasOwn"];
+var DEFAULT_MIN_VERSIONS = {
+  chrome: 93,
+  edge: 93,
+  firefox: 92,
+  safari: 15.4
+};
+var browserCheckPlugin = createPlugin((options = {}) => ({
+  name: "@4399ywkf/plugin-browser-check",
+  version: "1.0.0",
+  description: "\u6D4F\u89C8\u5668\u6700\u4F4E\u7248\u672C\u68C0\u67E5\u63D2\u4EF6",
+  setup(context) {
+    const {
+      features = DEFAULT_FEATURES,
+      minVersions: explicitVersions,
+      fromBrowserslist = false,
+      title = "\u6D4F\u89C8\u5668\u7248\u672C\u8FC7\u4F4E",
+      message = "\u60A8\u5F53\u524D\u7684\u6D4F\u89C8\u5668\u7248\u672C\u4E0D\u652F\u6301\u672C\u5E94\u7528\u6240\u9700\u7684\u529F\u80FD\u3002\u8BF7\u5347\u7EA7\u5230\u4EE5\u4E0B\u63A8\u8350\u6D4F\u89C8\u5668\u7684\u6700\u65B0\u7248\u672C\uFF1A",
+      showDownloadLinks = true,
+      renderHtml,
+      renderScript
+    } = options;
+    const { cwd, config, logger } = context;
+    const rootId = config.html.mountRoot || config.appName || "root";
+    let baseVersions = { ...DEFAULT_MIN_VERSIONS };
+    if (fromBrowserslist !== false) {
+      const parsed = parseBrowserslistConfig(cwd, fromBrowserslist, logger);
+      if (parsed) {
+        baseVersions = { ...baseVersions, ...parsed };
+      }
+    }
+    const minVersions = explicitVersions ? { ...baseVersions, ...explicitVersions } : baseVersions;
+    logger.info(
+      `\u6D4F\u89C8\u5668\u517C\u5BB9\u6027\u68C0\u67E5\u5DF2\u542F\u7528 (\u7279\u6027\u68C0\u6D4B: ${features.join(", ")})`
+    );
+    logger.info(
+      `\u6700\u4F4E\u7248\u672C\u8981\u6C42: Chrome ${minVersions.chrome ?? "\u2014"}, Edge ${minVersions.edge ?? "\u2014"}, Firefox ${minVersions.firefox ?? "\u2014"}, Safari ${minVersions.safari ?? "\u2014"}${fromBrowserslist !== false ? " (\u4ECE browserslist \u8BFB\u53D6)" : ""}`
+    );
+    const hooks = {
+      modifyEntryCode(code) {
+        const featureCheckLines = buildFeatureChecks(features);
+        const versionCheckLines = buildVersionChecks(minVersions);
+        const warningHtml = renderHtml ? renderHtml({ title, message, showDownloadLinks, minVersions }) : buildWarningHtml({ title, message, showDownloadLinks, minVersions });
+        const checkBlock = [
+          ``,
+          `// ======= \u6D4F\u89C8\u5668\u517C\u5BB9\u6027\u68C0\u67E5 (@4399ywkf/plugin-browser-check) =======`,
+          `const __ywkfBrowserOk = (() => {`,
+          `  try {`,
+          ...featureCheckLines.map((l) => `    ${l}`),
+          ...versionCheckLines.map((l) => `    ${l}`),
+          `    return true;`,
+          `  } catch {`,
+          `    return false;`,
+          `  }`,
+          `})();`,
+          ``,
+          `if (!__ywkfBrowserOk) {`,
+          `  const __root = document.getElementById(${JSON.stringify(rootId)}) || document.body;`,
+          `  __root.innerHTML = ${JSON.stringify(warningHtml)};`,
+          renderScript ? `  ${renderScript}` : ``,
+          `}`,
+          `// ======= End \u6D4F\u89C8\u5668\u517C\u5BB9\u6027\u68C0\u67E5 =======`,
+          ``
+        ].join("\n");
+        const lines = code.split("\n");
+        let lastImportIndex = -1;
+        for (let i = 0; i < lines.length; i++) {
+          if (lines[i].trimStart().startsWith("import ")) {
+            lastImportIndex = i;
+          }
+        }
+        const insertIndex = lastImportIndex >= 0 ? lastImportIndex + 1 : 0;
+        lines.splice(insertIndex, 0, checkBlock);
+        let result = lines.join("\n");
+        result = result.replace(
+          /(\s*)(await\s+)?runApp\(\);?/g,
+          (_, indent, awaitKw) => `${indent}if (__ywkfBrowserOk) { ${awaitKw || ""}runApp(); }`
+        );
+        return result;
+      }
+    };
+    return hooks;
+  }
+}));
+function buildFeatureChecks(features) {
+  if (features.length === 0) return [];
+  const lines = ["// \u7279\u6027\u68C0\u6D4B"];
+  for (const feature of features) {
+    const parts = feature.split(".");
+    if (parts.length === 1) {
+      lines.push(`if (typeof ${feature} === "undefined") return false;`);
+    } else {
+      lines.push(`if (typeof ${feature} !== "function") return false;`);
+    }
+  }
+  return lines;
+}
+function buildVersionChecks(minVersions) {
+  const entries = Object.entries(minVersions).filter(
+    ([, v]) => v != null
+  );
+  if (entries.length === 0) return [];
+  const lines = ["// UA \u7248\u672C\u68C0\u6D4B", "const ua = navigator.userAgent;"];
+  for (const [browser, minVer] of entries) {
+    switch (browser) {
+      case "chrome":
+        lines.push(
+          `const chromeMatch = /Chrome\\/(\\d+)/.exec(ua);`,
+          `if (chromeMatch && !/Edg\\//.test(ua) && Number(chromeMatch[1]) < ${minVer}) return false;`
+        );
+        break;
+      case "edge":
+        lines.push(
+          `const edgeMatch = /Edg\\/(\\d+)/.exec(ua);`,
+          `if (edgeMatch && Number(edgeMatch[1]) < ${minVer}) return false;`
+        );
+        break;
+      case "firefox":
+        lines.push(
+          `const firefoxMatch = /Firefox\\/(\\d+)/.exec(ua);`,
+          `if (firefoxMatch && Number(firefoxMatch[1]) < ${minVer}) return false;`
+        );
+        break;
+      case "safari":
+        lines.push(
+          `const safariMatch = /Version\\/(\\d+\\.?\\d*)/.exec(ua);`,
+          `if (safariMatch && /Safari/.test(ua) && !/Chrome/.test(ua) && Number(safariMatch[1]) < ${minVer}) return false;`
+        );
+        break;
+    }
+  }
+  return lines;
+}
+function buildWarningHtml(opts) {
+  const { title, message, showDownloadLinks, minVersions } = opts;
+  const versionHints = [
+    minVersions.chrome != null && `Chrome ${minVersions.chrome}+`,
+    minVersions.edge != null && `Edge ${minVersions.edge}+`,
+    minVersions.firefox != null && `Firefox ${minVersions.firefox}+`,
+    minVersions.safari != null && `Safari ${minVersions.safari}+`
+  ].filter(Boolean).join("\u3001");
+  const downloadLinksHtml = showDownloadLinks ? `<div style="display:flex;gap:12px;justify-content:center;flex-wrap:wrap;margin-top:32px">${browserLink("https://www.google.cn/chrome/", "Chrome \u6D4F\u89C8\u5668", "#4285f4", "#356ac3", "66,133,244")}${browserLink("https://www.microsoft.com/edge", "Edge \u6D4F\u89C8\u5668", "#0078d4", "#005a9e", "0,120,212")}${browserLink("https://www.firefox.com.cn/", "Firefox \u6D4F\u89C8\u5668", "#ff7139", "#e05a2b", "255,113,57")}</div>` : "";
+  const versionHintHtml = versionHints ? `<p style="margin:28px 0 0;font-size:13px;color:#aaa;letter-spacing:0.3px">\u63A8\u8350\u7248\u672C\uFF1A${versionHints}</p>` : "";
+  return [
+    `<div style="position:fixed;inset:0;z-index:99999;display:flex;align-items:center;justify-content:center;background:linear-gradient(135deg,#f5f7fa 0%,#c3cfe2 100%);font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,'PingFang SC','Microsoft YaHei',sans-serif;padding:24px;box-sizing:border-box">`,
+    `<div style="max-width:520px;width:100%;padding:48px 40px;background:#fff;border-radius:20px;box-shadow:0 8px 40px rgba(0,0,0,0.12);text-align:center">`,
+    // 警告图标
+    `<div style="width:80px;height:80px;margin:0 auto 28px;background:linear-gradient(135deg,#ff9a56,#ff6b6b);border-radius:50%;display:flex;align-items:center;justify-content:center;box-shadow:0 4px 20px rgba(255,107,107,0.3)">`,
+    `<svg width="40" height="40" viewBox="0 0 24 24" fill="none" stroke="#fff" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M10.29 3.86L1.82 18a2 2 0 001.71 3h16.94a2 2 0 001.71-3L13.71 3.86a2 2 0 00-3.42 0z"/><line x1="12" y1="9" x2="12" y2="13"/><line x1="12" y1="17" x2="12.01" y2="17"/></svg>`,
+    `</div>`,
+    // 标题 & 描述
+    `<h1 style="margin:0 0 16px;font-size:26px;font-weight:700;color:#1a1a2e;letter-spacing:-0.5px">${title}</h1>`,
+    `<p style="margin:0;font-size:15px;color:#666;line-height:1.8">${message}</p>`,
+    // 下载链接
+    downloadLinksHtml,
+    // 版本提示
+    versionHintHtml,
+    `</div></div>`
+  ].join("");
+}
+function browserLink(href, label, colorStart, colorEnd, rgbBase) {
+  const bg = `background:linear-gradient(135deg,${colorStart},${colorEnd})`;
+  const shadow = `box-shadow:0 4px 12px rgba(${rgbBase},0.3)`;
+  const hoverShadow = `0 6px 20px rgba(${rgbBase},0.4)`;
+  const base = `display:inline-flex;align-items:center;padding:14px 28px;${bg};color:#fff;border-radius:12px;text-decoration:none;font-size:15px;font-weight:500;${shadow};transition:transform .2s,box-shadow .2s`;
+  return `<a href="${href}" target="_blank" rel="noopener noreferrer" style="${base}" onmouseover="this.style.transform='translateY(-2px)';this.style.boxShadow='${hoverShadow}'" onmouseout="this.style.transform='';this.style.boxShadow='0 4px 12px rgba(${rgbBase},0.3)'">${label}</a>`;
+}
+var BROWSERSLIST_NAME_MAP = {
+  chrome: "chrome",
+  chromium: "chrome",
+  edge: "edge",
+  firefox: "firefox",
+  ff: "firefox",
+  safari: "safari",
+  ios_saf: "safari"
+};
+function parseBrowserslistConfig(cwd, source, logger) {
+  let queries = [];
+  if (typeof source === "string") {
+    const filePath = join2(cwd, source);
+    if (!existsSync2(filePath)) {
+      logger.warn(`browserslist \u6587\u4EF6\u672A\u627E\u5230: ${filePath}`);
+      return null;
+    }
+    queries = readBrowserslistFile(filePath);
+    logger.info(`\u4ECE ${source} \u8BFB\u53D6\u5230 ${queries.length} \u6761 browserslist \u67E5\u8BE2`);
+  } else {
+    const rcPath = join2(cwd, ".browserslistrc");
+    if (existsSync2(rcPath)) {
+      queries = readBrowserslistFile(rcPath);
+      logger.info(`\u4ECE .browserslistrc \u8BFB\u53D6\u5230 ${queries.length} \u6761 browserslist \u67E5\u8BE2`);
+    } else {
+      const pkgPath = join2(cwd, "package.json");
+      if (existsSync2(pkgPath)) {
+        try {
+          const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+          if (Array.isArray(pkg.browserslist)) {
+            queries = pkg.browserslist;
+            logger.info(`\u4ECE package.json#browserslist \u8BFB\u53D6\u5230 ${queries.length} \u6761\u67E5\u8BE2`);
+          } else if (typeof pkg.browserslist === "string") {
+            queries = [pkg.browserslist];
+            logger.info("\u4ECE package.json#browserslist \u8BFB\u53D6\u5230 1 \u6761\u67E5\u8BE2");
+          }
+        } catch {
+        }
+      }
+    }
+    if (queries.length === 0) {
+      logger.warn("\u672A\u627E\u5230 .browserslistrc \u6216 package.json#browserslist\uFF0C\u5C06\u4F7F\u7528\u5185\u7F6E\u9ED8\u8BA4\u503C");
+      return null;
+    }
+  }
+  return extractMinVersions(queries);
+}
+function readBrowserslistFile(filePath) {
+  const content = readFileSync(filePath, "utf-8");
+  return content.split("\n").map((line) => line.replace(/#.*$/, "").trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+function extractMinVersions(queries) {
+  const result = {};
+  const expanded = queries.flatMap((q) => q.split(",").map((s) => s.trim()));
+  const versionPattern = /^(\w+)\s*(?:(>=?)\s*)?(\d+(?:\.\d+)?)\s*$/i;
+  for (const query of expanded) {
+    if (/^(not|dead|last|defaults|>?\s*\d+%|unreleased|current)/i.test(query)) {
+      continue;
+    }
+    const match = versionPattern.exec(query);
+    if (!match) continue;
+    const [, browserName, operator, versionStr] = match;
+    const key = BROWSERSLIST_NAME_MAP[browserName.toLowerCase()];
+    if (!key) continue;
+    let version2 = Number.parseFloat(versionStr);
+    if (operator === ">") {
+      version2 = Math.ceil(version2) + 1;
+    }
+    if (result[key] == null || version2 < result[key]) {
+      result[key] = version2;
+    }
+  }
+  return result;
+}
+
+// src/plugin/builtin/garfish.ts
+var garfishPlugin = createPlugin((options = {}) => ({
+  name: "@4399ywkf/plugin-garfish",
+  version: "1.0.0",
+  description: "Garfish \u5FAE\u524D\u7AEF\u63D2\u4EF6",
+  setup(context) {
+    const { appName, master = false, apps = [], sandbox = {} } = options;
+    const { config, logger, isDev } = context;
+    const finalAppName = appName || config.appName;
+    const hooks = {
+      // ===== 构建阶段钩子 =====
+      modifyRspackConfig(rspackConfig) {
+        if (!master) {
+          rspackConfig.output = {
+            ...rspackConfig.output,
+            library: finalAppName,
+            libraryTarget: "umd",
+            globalObject: "window",
+            chunkLoadingGlobal: `garfish_${finalAppName}`
+          };
+          rspackConfig.devServer = {
+            ...rspackConfig.devServer,
+            headers: {
+              ...rspackConfig.devServer?.headers || {},
+              "Access-Control-Allow-Origin": "*",
+              "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+              "Access-Control-Allow-Headers": "*"
+            }
+          };
+          logger.info(`\u914D\u7F6E UMD \u8F93\u51FA: ${finalAppName}`);
+        }
+        return rspackConfig;
+      },
+      beforeDevServer() {
+        if (master) {
+          logger.info("Garfish \u4E3B\u5E94\u7528\u6A21\u5F0F");
+          logger.info(`\u5B50\u5E94\u7528\u5217\u8868: ${apps.map((a) => a.name).join(", ")}`);
+        } else {
+          logger.info(`Garfish \u5B50\u5E94\u7528\u6A21\u5F0F: ${finalAppName}`);
+        }
+      },
+      // ===== 代码生成阶段钩子 =====
+      injectEntry(_ctx) {
+        if (master && apps.length > 0) {
+          return {
+            imports: [`import { initGarfishMaster } from "./bootstrap";`],
+            topLevel: [`// Garfish \u4E3B\u5E94\u7528\uFF1A\u521D\u59CB\u5316\u5FAE\u524D\u7AEF\u5E76\u6CE8\u518C\u5B50\u5E94\u7528`, `await initGarfishMaster();`]
+          };
+        }
+        if (!master) {
+          return {
+            imports: [`import { garfishProvider, isMicroAppEnv } from "./bootstrap";`],
+            exports: [
+              `// Garfish \u5B50\u5E94\u7528\u751F\u547D\u5468\u671F\u5BFC\u51FA\uFF08provider \u51FD\u6570\u683C\u5F0F\uFF09`,
+              `export const provider = garfishProvider;`
+            ],
+            topLevel: [
+              `// Garfish \u5FAE\u524D\u7AEF\uFF1A\u72EC\u7ACB\u8FD0\u884C\u5224\u65AD`,
+              `const shouldRunIndependently = !isMicroAppEnv();`
+            ]
+          };
+        }
+        return {};
+      },
+      injectBootstrap(_ctx) {
+        const imports = [];
+        const exports = [];
+        const topLevel = [];
+        if (master) {
+          if (apps.length > 0) {
+            imports.push(`import Garfish from "garfish";`);
+            topLevel.push(generateMasterInitCode(apps, config.router.basename));
+          }
+        } else {
+          imports.push(
+            `import { createGarfishProvider, isMicroAppEnv } from "@4399ywkf/core/runtime";`
+          );
+          exports.push(
+            `/**`,
+            ` * Garfish \u5B50\u5E94\u7528 provider\uFF08render/destroy \u683C\u5F0F\uFF09`,
+            ` */`,
+            `export const garfishProvider = createGarfishProvider(createAppConfig);`,
+            ``,
+            `/**`,
+            ` * \u5224\u65AD\u662F\u5426\u5728\u5FAE\u524D\u7AEF\u73AF\u5883`,
+            ` */`,
+            `export { isMicroAppEnv };`
+          );
+        }
+        return { imports, exports, topLevel };
+      },
+      modifyBootstrapCode(code, _ctx) {
+        if (!master) {
+          return code.replace(/antd:\s*\{\s*enabled:\s*true/, "antd: { enabled: false");
+        }
+        return code;
+      },
+      // ===== 运行时阶段钩子 =====
+      modifyAppConfig(appConfig) {
+        return {
+          ...appConfig,
+          // 微前端模式下禁用 antd 样式注入（由主应用管理）
+          antd: {
+            ...appConfig.antd,
+            enabled: master
+          }
+        };
+      }
+    };
+    return hooks;
+  }
+}));
+function generateMasterInitCode(apps, basename) {
+  const appConfigs = apps.map(
+    (app) => `{
+    name: "${app.name}",
+    entry: "${app.entry}",
+    activeWhen: "${app.activeRule}",
+    ${app.basename ? `basename: "${app.basename}",` : ""}
+  }`
+  ).join(",\n    ");
+  return `
+/**
+ * Garfish \u4E3B\u5E94\u7528\u521D\u59CB\u5316
+ * \u5728 runApp \u4E4B\u524D\u8C03\u7528
+ */
+export async function initGarfishMaster(): Promise<void> {
+  await Garfish.run({
+    basename: "${basename || "/"}",
+    domGetter: "#subapp-container",
+    apps: [
+      ${appConfigs}
+    ],
+  });
+}
+`;
+}
+
+// src/plugin/builtin/i18n.ts
+import { existsSync as existsSync3, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+var i18nPlugin = createPlugin((options = {}) => ({
+  name: "@4399ywkf/plugin-i18n",
+  version: "1.0.0",
+  description: "\u56FD\u9645\u5316 (i18next) \u63D2\u4EF6 \u2014 TS-first \u5DE5\u4F5C\u6D41",
+  setup(context) {
+    const {
+      defaultLocale = "zh-CN",
+      locales = ["zh-CN", "en-US"],
+      localesDir = "locales",
+      sourceDir = "src/locales/default",
+      defaultNS = ["common"],
+      autoScaffold = true
+    } = options;
+    const { cwd, logger, isDev } = context;
+    if (autoScaffold) {
+      scaffoldSourceFiles(cwd, sourceDir, defaultNS, logger);
+      scaffoldResourcesFile(cwd, sourceDir, defaultNS, locales, defaultLocale, logger);
+      scaffoldConvertScript(cwd, sourceDir, localesDir, defaultLocale, logger);
+      scaffoldI18nRc(cwd, localesDir, defaultLocale, locales, logger);
+      scaffoldLocaleJsonDirs(cwd, localesDir, locales, defaultLocale, defaultNS, logger);
+    }
+    const hooks = {
+      modifyRspackConfig(rspackConfig) {
+        const aliases = rspackConfig.resolve?.alias || {};
+        if (!aliases["@locales"]) {
+          aliases["@locales"] = join3(cwd, localesDir);
+        }
+        rspackConfig.resolve = { ...rspackConfig.resolve, alias: aliases };
+        return rspackConfig;
+      },
+      generateFiles(_ctx) {
+        return [
+          {
+            path: "i18n.ts",
+            content: generateI18nCode({
+              defaultLocale,
+              locales,
+              localesDir,
+              sourceDir,
+              defaultNS,
+              isDev
+            })
+          }
+        ];
+      },
+      injectBootstrap(_ctx) {
+        return {
+          imports: [`import { initI18n } from "./i18n";`],
+          topLevel: [`await initI18n();`]
+        };
+      }
+    };
+    return hooks;
+  }
+}));
+function generateI18nCode(opts) {
+  const { defaultLocale, locales, defaultNS, sourceDir } = opts;
+  const defaultDirAlias = sourceDir.replace(/^src\//, "");
+  const parentDirAlias = defaultDirAlias.replace(/\/[^/]+$/, "");
+  return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/plugin-i18n \u81EA\u52A8\u751F\u6210
+import i18n from "i18next";
+import LanguageDetector from "i18next-browser-languagedetector";
+import resourcesToBackend from "i18next-resources-to-backend";
+import { initReactI18next } from "react-i18next";
+import { normalizeLocale, SUPPORTED_LOCALES, DEFAULT_LOCALE } from "@/${parentDirAlias}/resources";
+
+export { DEFAULT_LOCALE, SUPPORTED_LOCALES, normalizeLocale };
+export type { SupportedLocale, NS } from "@/${parentDirAlias}/resources";
+
+const isDev = process.env.NODE_ENV === "development";
+
+const instance = i18n
+  .use(initReactI18next)
+  .use(LanguageDetector)
+  .use(
+    resourcesToBackend(async (lng: string, ns: string) => {
+      const normalizedLng = normalizeLocale(lng);
+
+      // \u5F00\u53D1\u6A21\u5F0F\u4E0B\uFF0C\u9ED8\u8BA4\u8BED\u8A00\u76F4\u63A5 import TS\uFF08\u5373\u65F6\u751F\u6548\uFF0C\u65E0\u9700\u5148\u751F\u6210 JSON\uFF09
+      if (isDev && normalizedLng === "${defaultLocale}") {
+        return import("@/${defaultDirAlias}/" + ns);
+      }
+
+      // \u5176\u4ED6\u8BED\u8A00 / \u751F\u4EA7\u6A21\u5F0F\uFF1A\u61D2\u52A0\u8F7D JSON
+      return import(
+        /* webpackInclude: /\\.json$/ */
+        /* webpackChunkName: "locales-[request]" */
+        \`@locales/\${normalizedLng}/\${ns}.json\`
+      );
+    })
+  );
+
+let initialized = false;
+
+export async function initI18n(lang?: string): Promise<typeof i18n> {
+  if (initialized) return instance;
+
+  await instance.init({
+    defaultNS: ${JSON.stringify(defaultNS)},
+    fallbackLng: DEFAULT_LOCALE,
+    interpolation: { escapeValue: false },
+    lng: lang,
+  });
+
+  initialized = true;
+  return instance;
+}
+
+export { instance as i18n };
+export default instance;
+`;
+}
+function scaffoldSourceFiles(cwd, sourceDir, namespaces, logger) {
+  const dir = join3(cwd, sourceDir);
+  if (!existsSync3(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  for (const ns of namespaces) {
+    const filePath = join3(dir, `${ns}.ts`);
+    if (!existsSync3(filePath)) {
+      writeFileSync2(filePath, buildDefaultNsFile(ns), "utf-8");
+      logger.info(`\u5DF2\u751F\u6210\u7FFB\u8BD1\u6E90\u6587\u4EF6: ${sourceDir}/${ns}.ts`);
+    }
+  }
+  const indexPath = join3(dir, "index.ts");
+  if (!existsSync3(indexPath)) {
+    const imports = namespaces.map((ns) => `import ${ns} from "./${ns}";`).join("\n");
+    const entries = namespaces.join(",\n  ");
+    const content = `${imports}
+
+const resources = {
+  ${entries},
+} as const;
+
+export default resources;
+`;
+    writeFileSync2(indexPath, content, "utf-8");
+    logger.info(`\u5DF2\u751F\u6210\u7FFB\u8BD1\u7D22\u5F15: ${sourceDir}/index.ts`);
+  }
+}
+function buildDefaultNsFile(ns) {
+  if (ns === "common") {
+    return `export default {
+  welcome: "\u6B22\u8FCE\u4F7F\u7528",
+  loading: "\u52A0\u8F7D\u4E2D...",
+  confirm: "\u786E\u5B9A",
+  cancel: "\u53D6\u6D88",
+  save: "\u4FDD\u5B58",
+  delete: "\u5220\u9664",
+  edit: "\u7F16\u8F91",
+  back: "\u8FD4\u56DE",
+} as const;
+`;
+  }
+  return `export default {
+  title: "${ns}",
+} as const;
+`;
+}
+function scaffoldResourcesFile(cwd, sourceDir, _namespaces, locales, defaultLocale, logger) {
+  const parentDir = join3(cwd, sourceDir, "..");
+  const filePath = join3(parentDir, "resources.ts");
+  if (existsSync3(filePath)) return;
+  const content = `import resources from "./default";
+
+export const DEFAULT_LOCALE = "${defaultLocale}";
+
+export const SUPPORTED_LOCALES = ${JSON.stringify(locales)} as const;
+
+export type SupportedLocale = (typeof SUPPORTED_LOCALES)[number];
+
+export type DefaultResources = typeof resources;
+
+export type NS = keyof DefaultResources;
+
+export const normalizeLocale = (locale?: string): SupportedLocale => {
+  if (!locale) return DEFAULT_LOCALE as SupportedLocale;
+
+  for (const l of SUPPORTED_LOCALES) {
+    if (l.startsWith(locale) || locale.startsWith(l.split("-")[0])) {
+      return l;
+    }
+  }
+
+  return DEFAULT_LOCALE as SupportedLocale;
+};
+
+export const localeOptions = ${JSON.stringify(
+    locales.map((l) => ({ value: l, label: getLocaleLabel(l) })),
+    null,
+    2
+  )} as const;
+`;
+  writeFileSync2(filePath, content, "utf-8");
+  logger.info(`\u5DF2\u751F\u6210\u7C7B\u578B\u6587\u4EF6: ${sourceDir}/../resources.ts`);
+}
+function getLocaleLabel(locale) {
+  const map = {
+    "zh-CN": "\u7B80\u4F53\u4E2D\u6587",
+    "zh-TW": "\u7E41\u9AD4\u4E2D\u6587",
+    "en-US": "English",
+    "ja-JP": "\u65E5\u672C\u8A9E",
+    "ko-KR": "\uD55C\uAD6D\uC5B4",
+    "de-DE": "Deutsch",
+    "fr-FR": "Fran\xE7ais",
+    "es-ES": "Espa\xF1ol",
+    "pt-BR": "Portugu\xEAs",
+    "ru-RU": "\u0420\u0443\u0441\u0441\u043A\u0438\u0439",
+    "it-IT": "Italiano",
+    "vi-VN": "Ti\u1EBFng Vi\u1EC7t",
+    ar: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629"
+  };
+  return map[locale] || locale;
+}
+function scaffoldConvertScript(cwd, sourceDir, localesDir, defaultLocale, logger) {
+  const scriptsDir = join3(cwd, "scripts");
+  const scriptPath = join3(scriptsDir, "i18n-gen.js");
+  if (existsSync3(scriptPath)) return;
+  if (!existsSync3(scriptsDir)) {
+    mkdirSync(scriptsDir, { recursive: true });
+  }
+  const content = `const fs = require("fs");
+const path = require("path");
+
+const sourceDir = path.join(__dirname, "../${sourceDir}");
+const targetDir = path.join(__dirname, "../${localesDir}/${defaultLocale}");
+
+const files = fs
+  .readdirSync(sourceDir)
+  .filter((file) => file.endsWith(".ts") && file !== "index.ts")
+  .map((file) => path.basename(file, ".ts"));
+
+require("ts-node/register");
+
+if (!fs.existsSync(targetDir)) {
+  fs.mkdirSync(targetDir, { recursive: true });
+}
+
+console.log("\u5F00\u59CB\u8F6C\u6362 TypeScript \u6587\u4EF6\u5230 JSON...\\n");
+
+files.forEach((fileName) => {
+  try {
+    const modulePath = path.join(sourceDir, \`\${fileName}.ts\`);
+    delete require.cache[require.resolve(modulePath)];
+    const moduleContent = require(modulePath).default;
+    const jsonContent = JSON.stringify(moduleContent, null, 2);
+    const targetPath = path.join(targetDir, \`\${fileName}.json\`);
+    fs.writeFileSync(targetPath, jsonContent, "utf8");
+    console.log(\`  \${fileName}.ts \u2192 \${fileName}.json\`);
+  } catch (error) {
+    console.error(\`  \u8F6C\u6362 \${fileName}.ts \u5931\u8D25:\`, error.message);
+  }
+});
+
+console.log("\\n\u8F6C\u6362\u5B8C\u6210\uFF01");
+`;
+  writeFileSync2(scriptPath, content, "utf-8");
+  logger.info("\u5DF2\u751F\u6210\u8F6C\u6362\u811A\u672C: scripts/i18n-gen.js");
+}
+function scaffoldI18nRc(cwd, localesDir, defaultLocale, locales, logger) {
+  const filePath = join3(cwd, ".i18nrc.js");
+  if (existsSync3(filePath)) return;
+  const outputLocales = locales.filter((l) => l !== defaultLocale).map((l) => `"${l}"`).join(", ");
+  const content = `const { defineConfig } = require("@lobehub/i18n-cli");
+
+module.exports = defineConfig({
+  entry: "${localesDir}/${defaultLocale}",
+  entryLocale: "${defaultLocale}",
+  output: "${localesDir}",
+  outputLocales: [${outputLocales}],
+});
+`;
+  writeFileSync2(filePath, content, "utf-8");
+  logger.info("\u5DF2\u751F\u6210\u7FFB\u8BD1\u914D\u7F6E: .i18nrc.js\uFF08@lobehub/i18n-cli\uFF09");
+}
+function scaffoldLocaleJsonDirs(cwd, localesDir, locales, defaultLocale, namespaces, logger) {
+  const baseDir = join3(cwd, localesDir);
+  for (const locale of locales) {
+    const localeDir = join3(baseDir, locale);
+    if (!existsSync3(localeDir)) {
+      mkdirSync(localeDir, { recursive: true });
+    }
+    if (locale === defaultLocale) continue;
+    for (const ns of namespaces) {
+      const filePath = join3(localeDir, `${ns}.json`);
+      if (!existsSync3(filePath)) {
+        const placeholder = ns === "common" ? JSON.stringify(
+          {
+            welcome: "Welcome",
+            loading: "Loading...",
+            confirm: "OK",
+            cancel: "Cancel",
+            save: "Save",
+            delete: "Delete",
+            edit: "Edit",
+            back: "Back"
+          },
+          null,
+          2
+        ) : JSON.stringify({ title: ns }, null, 2);
+        writeFileSync2(filePath, `${placeholder}
+`, "utf-8");
+        logger.info(`\u5DF2\u751F\u6210\u7FFB\u8BD1\u6587\u4EF6: ${localesDir}/${locale}/${ns}.json`);
+      }
+    }
+  }
+}
+
+// src/plugin/builtin/mock.ts
+import { existsSync as existsSync4, readdirSync, statSync } from "fs";
+import { join as join4, resolve } from "path";
+var mockPlugin = createPlugin((options = {}) => ({
+  name: "@4399ywkf/plugin-mock",
+  version: "1.0.0",
+  description: "Mock \u6570\u636E\u63D2\u4EF6",
+  setup(context) {
+    const { mockDir = "mock", enableInProd = false, delay = 0, prefix = "" } = options;
+    const { cwd, isDev, logger } = context;
+    if (!isDev && !enableInProd) {
+      logger.info("\u751F\u4EA7\u73AF\u5883\u5DF2\u7981\u7528 Mock");
+      return {};
+    }
+    const mockPath = resolve(cwd, mockDir);
+    if (!existsSync4(mockPath)) {
+      logger.warn(`Mock \u76EE\u5F55\u4E0D\u5B58\u5728: ${mockPath}`);
+      return {};
+    }
+    const hooks = {
+      modifyRspackConfig(rspackConfig) {
+        if (isDev && rspackConfig.devServer) {
+          const mockFiles = scanMockFiles(mockPath);
+          logger.info(`\u627E\u5230 ${mockFiles.length} \u4E2A Mock \u6587\u4EF6`);
+          rspackConfig.devServer.setupMiddlewares = (middlewares, _devServer) => {
+            middlewares.unshift({
+              name: "mock-middleware",
+              middleware: createMockMiddleware(mockPath, { delay, prefix, logger })
+            });
+            return middlewares;
+          };
+        }
+        return rspackConfig;
+      },
+      beforeDevServer() {
+        logger.info(`Mock \u5DF2\u542F\u7528\uFF0C\u76EE\u5F55: ${mockPath}`);
+        if (delay > 0) {
+          logger.info(`\u6A21\u62DF\u5EF6\u8FDF: ${delay}ms`);
+        }
+      }
+    };
+    return hooks;
+  }
+}));
+function scanMockFiles(dir) {
+  const files = [];
+  if (!existsSync4(dir)) {
+    return files;
+  }
+  const entries = readdirSync(dir);
+  for (const entry of entries) {
+    const fullPath = join4(dir, entry);
+    const stat = statSync(fullPath);
+    if (stat.isFile() && /\.(ts|js|mjs)$/.test(entry)) {
+      files.push(fullPath);
+    } else if (stat.isDirectory()) {
+      files.push(...scanMockFiles(fullPath));
+    }
+  }
+  return files;
+}
+function createMockMiddleware(mockPath, options) {
+  const { delay } = options;
+  scanMockFiles(mockPath);
+  return async (_req, _res, next) => {
+    if (delay > 0) {
+      await new Promise((resolve4) => setTimeout(resolve4, delay));
+    }
+    next();
+  };
+}
+
+// src/plugin/builtin/react-query.ts
+var reactQueryPlugin = createPlugin((options = {}) => ({
+  name: "@4399ywkf/plugin-react-query",
+  version: "1.0.0",
+  description: "React Query + Axios \u8BF7\u6C42\u5C42\u96C6\u6210",
+  setup(context) {
+    const {
+      staleTime = 5 * 60 * 1e3,
+      gcTime = 10 * 60 * 1e3,
+      retry = 1,
+      devtools = true,
+      baseURL = "",
+      timeout = 15e3
+    } = options;
+    const { logger, isDev } = context;
+    const hooks = {
+      generateFiles(_ctx) {
+        logger.info("React Query \u5DF2\u542F\u7528");
+        const files = [
+          {
+            path: "query-client.ts",
+            content: buildQueryClientFile({ staleTime, gcTime, retry, devtools, isDev })
+          },
+          {
+            path: "request.ts",
+            content: buildRequestFile({ baseURL, timeout })
+          }
+        ];
+        return files;
+      },
+      injectBootstrap(_ctx) {
+        return {
+          imports: [
+            `import { QueryClientProvider } from "@tanstack/react-query";`,
+            `import { queryClient } from "./query-client";`
+          ],
+          topLevel: [`// React Query Provider\uFF08\u7531 @4399ywkf/plugin-react-query \u6CE8\u5165\uFF09`]
+        };
+      },
+      modifyBootstrapCode(code) {
+        const providerEntry = `    {
+      component: QueryClientProvider as React.ComponentType<{ children: React.ReactNode }>,
+      props: { client: queryClient },
+      order: 20,
+    }`;
+        if (code.includes("providers: []")) {
+          code = code.replace("providers: []", `providers: [
+${providerEntry},
+  ]`);
+        } else if (code.includes("providers: [")) {
+          code = code.replace("providers: [", `providers: [
+${providerEntry},`);
+        }
+        if (!code.includes("import React")) {
+          code = code.replace(
+            `import { bootstrap`,
+            `import React from "react";
+import { bootstrap`
+          );
+        }
+        return code;
+      }
+    };
+    return hooks;
+  }
+}));
+function buildQueryClientFile(opts) {
+  const { staleTime, gcTime, retry, devtools, isDev } = opts;
+  return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/plugin-react-query \u81EA\u52A8\u751F\u6210
+import { QueryClient } from "@tanstack/react-query";
+
+/**
+ * \u5168\u5C40 QueryClient \u5B9E\u4F8B
+ *
+ * \u9ED8\u8BA4\u914D\u7F6E\u53EF\u5728 ywkf.config.ts \u7684 reactQueryPlugin \u9009\u9879\u4E2D\u4FEE\u6539\u3002
+ * \u8FD0\u884C\u65F6\u81EA\u5B9A\u4E49\u53EF\u901A\u8FC7 src/app.config.ts \u8986\u76D6\u3002
+ */
+export const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: ${staleTime},
+      gcTime: ${gcTime},
+      retry: ${typeof retry === "boolean" ? retry : retry},
+      refetchOnWindowFocus: false,
+    },
+    mutations: {
+      retry: false,
+    },
+  },
+});
+
+export default queryClient;
+`;
+}
+function buildRequestFile(opts) {
+  const { baseURL, timeout } = opts;
+  return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/plugin-react-query \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u4FEE\u6539
+// \u5982\u9700\u5B9A\u5236\u62E6\u622A\u5668\uFF0C\u8BF7\u7F16\u8F91 src/request.ts
+import axios from "axios";
+import qs from "qs";
+import type { AxiosInstance, AxiosRequestConfig, InternalAxiosRequestConfig, AxiosResponse, AxiosError } from "axios";
+import type { RequestConfig, Result } from "@4399ywkf/core/runtime";
+
+// ============ \u52A0\u8F7D\u7528\u6237\u914D\u7F6E ============
+
+let userConfig: RequestConfig = {};
+
+try {
+  const mod = require("@/request");
+  userConfig = mod.default || mod;
+} catch {
+  // src/request.ts \u4E0D\u5B58\u5728\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E
+}
+
+// ============ \u53C2\u6570\u5E8F\u5217\u5316\uFF08GET \u8BF7\u6C42\u4E13\u7528\uFF09============
+
+/**
+ * GET \u8BF7\u6C42\u53C2\u6570\u5E8F\u5217\u5316\u89C4\u5219\uFF1A
+ * - \u6570\u7EC4\uFF1Arepeat \u6A21\u5F0F\uFF08key=1&key=2\uFF09
+ * - \u5BF9\u8C61\uFF1AJSON.stringify \u540E\u4F5C\u4E3A\u5B57\u7B26\u4E32\u4F20\u9012
+ * - null / undefined\uFF1AskipNulls \u8DF3\u8FC7
+ * - \u57FA\u672C\u7C7B\u578B\uFF1A\u539F\u6837\u4F20\u9012
+ */
+export function paramsSerializer(params: Record<string, any>): string {
+  const normalized: Record<string, any> = {};
+
+  Object.keys(params).forEach((key) => {
+    const value = params[key];
+
+    if (value === null || value === undefined) {
+      normalized[key] = value;
+    } else if (Array.isArray(value)) {
+      normalized[key] = value;
+    } else if (typeof value === "object") {
+      normalized[key] = JSON.stringify(value);
+    } else {
+      normalized[key] = value;
+    }
+  });
+
+  return qs.stringify(normalized, { arrayFormat: "repeat", skipNulls: true });
+}
+
+// ============ \u521B\u5EFA Axios \u5B9E\u4F8B ============
+
+const instance: AxiosInstance = axios.create({
+  baseURL: userConfig.baseURL ?? ("${baseURL}" || ""),
+  timeout: userConfig.timeout ?? ${timeout},
+  withCredentials: userConfig.withCredentials ?? false,
+  headers: {
+    "Content-Type": "application/json",
+    ...(userConfig.headers || {}),
+  },
+});
+
+// ============ \u8BF7\u6C42\u62E6\u622A\u5668 ============
+
+instance.interceptors.request.use(
+  (config: InternalAxiosRequestConfig) => {
+    // 1. Token \u6CE8\u5165
+    if (userConfig.getToken) {
+      const token = userConfig.getToken();
+      if (token && config.headers) {
+        const prefix = userConfig.tokenPrefix ?? "Bearer";
+        config.headers.Authorization = prefix ? \`\${prefix} \${token}\` : token;
+      }
+    } else {
+      // \u9ED8\u8BA4\uFF1A\u4ECE localStorage \u8BFB\u53D6
+      const token = typeof localStorage !== "undefined"
+        ? localStorage.getItem("token")
+        : null;
+      if (token && config.headers) {
+        config.headers.Authorization = \`Bearer \${token}\`;
+      }
+    }
+
+    // 2. \u7528\u6237\u81EA\u5B9A\u4E49\u8BF7\u6C42\u62E6\u622A
+    if (userConfig.requestInterceptor) {
+      return userConfig.requestInterceptor(config as any) as any;
+    }
+
+    return config;
+  },
+  (error: AxiosError) => Promise.reject(error)
+);
+
+// ============ \u54CD\u5E94\u62E6\u622A\u5668 ============
+
+instance.interceptors.response.use(
+  (response: AxiosResponse) => {
+    // \u7528\u6237\u81EA\u5B9A\u4E49\u54CD\u5E94\u62E6\u622A
+    if (userConfig.responseInterceptor) {
+      return userConfig.responseInterceptor(response as any);
+    }
+
+    // \u9ED8\u8BA4\uFF1A\u76F4\u63A5\u8FD4\u56DE response.data
+    return response.data;
+  },
+  (error: AxiosError) => {
+    // \u7528\u6237\u81EA\u5B9A\u4E49\u9519\u8BEF\u5904\u7406
+    if (userConfig.errorHandler) {
+      return userConfig.errorHandler(error as any);
+    }
+
+    // \u9ED8\u8BA4\u9519\u8BEF\u5904\u7406
+    const status = error.response?.status;
+
+    switch (status) {
+      case 401:
+        console.warn("[request] \u672A\u6388\u6743\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55");
+        break;
+      case 403:
+        console.warn("[request] \u65E0\u8BBF\u95EE\u6743\u9650");
+        break;
+      case 500:
+        console.error("[request] \u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF");
+        break;
+      default:
+        if (!error.response) {
+          console.error("[request] \u7F51\u7EDC\u5F02\u5E38\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5");
+        }
+    }
+
+    return Promise.reject(error);
+  }
+);
+
+// ============ \u8BF7\u6C42\u5C01\u88C5\u7C7B ============
+
+type ExtraConfig = AxiosRequestConfig & { suppressErrorNotification?: boolean };
+
+class Request {
+  constructor(private readonly http: AxiosInstance) {}
+
+  get<T = any>(url: string, params?: Record<string, any>, config?: ExtraConfig): Promise<Result<T>> {
+    return this.http.get(url, {
+      ...config,
+      params,
+      paramsSerializer,
+    });
+  }
+
+  post<T = any>(url: string, data?: any, config?: ExtraConfig): Promise<Result<T>> {
+    return this.http.post(url, data, config);
+  }
+
+  put<T = any>(url: string, data?: any, config?: ExtraConfig): Promise<Result<T>> {
+    return this.http.put(url, data, config);
+  }
+
+  delete<T = any>(url: string, params?: Record<string, any>, config?: ExtraConfig): Promise<Result<T>> {
+    return this.http.delete(url, {
+      ...config,
+      params,
+      paramsSerializer,
+    });
+  }
+
+  patch<T = any>(url: string, data?: any, config?: ExtraConfig): Promise<Result<T>> {
+    return this.http.patch(url, data, config);
+  }
+}
+
+// ============ \u5BFC\u51FA ============
+
+export const request = new Request(instance);
+export type { Result };
+export default request;
+`;
+}
+
+// src/plugin/builtin/tailwind.ts
+import { existsSync as existsSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
+import { rspack } from "@rspack/core";
+var tailwindPlugin = createPlugin((options = {}) => ({
+  name: "@4399ywkf/plugin-tailwind",
+  version: "1.0.0",
+  description: "Tailwind CSS \u96C6\u6210\u63D2\u4EF6",
+  setup(context) {
+    const {
+      darkModeSelector = '&:where([data-theme="dark"], [data-theme="dark"] *)',
+      autoConfig = true,
+      extraCSS = ""
+    } = options;
+    const { cwd, logger } = context;
+    if (autoConfig) {
+      ensurePostcssConfig(cwd, logger);
+    }
+    const hooks = {
+      modifyRspackConfig(rspackConfig) {
+        logger.info("Tailwind CSS \u5DF2\u542F\u7528");
+        const rules = rspackConfig.module?.rules || [];
+        const postcssConfigPath = join5(cwd, "postcss.config.js");
+        const isProd = rspackConfig.mode === "production";
+        const tailwindRule = {
+          test: /tailwind\.css$/,
+          use: [
+            isProd ? rspack.CssExtractRspackPlugin.loader : "style-loader",
+            "css-loader",
+            {
+              loader: "postcss-loader",
+              options: {
+                postcssOptions: {
+                  config: postcssConfigPath
+                }
+              }
+            }
+          ]
+        };
+        rules.unshift(tailwindRule);
+        rspackConfig.module = { ...rspackConfig.module, rules };
+        return rspackConfig;
+      },
+      generateFiles(_ctx) {
+        const cssContent = buildTailwindCSS(darkModeSelector, extraCSS);
+        return [
+          {
+            path: "tailwind.css",
+            content: cssContent
+          }
+        ];
+      },
+      injectEntry(_ctx) {
+        return {
+          imports: [`import "./tailwind.css";`]
+        };
+      }
+    };
+    return hooks;
+  }
+}));
+function buildTailwindCSS(darkModeSelector, extraCSS) {
+  return `/* \u6B64\u6587\u4EF6\u7531 @4399ywkf/plugin-tailwind \u81EA\u52A8\u751F\u6210 */
+@import "tailwindcss";
+@variant dark (${darkModeSelector});
+${extraCSS ? `
+${extraCSS}` : ""}
+`;
+}
+function ensurePostcssConfig(cwd, logger) {
+  const configPath = join5(cwd, "postcss.config.js");
+  if (!existsSync5(configPath)) {
+    writeFileSync3(
+      configPath,
+      `module.exports = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+`,
+      "utf-8"
+    );
+    logger.info("\u5DF2\u81EA\u52A8\u751F\u6210 postcss.config.js");
+  }
+}
+
+// src/plugin/builtin/theme.ts
+import { join as join6 } from "path";
+var themePlugin = createPlugin((options = {}) => ({
+  name: "@4399ywkf/plugin-theme",
+  version: "3.0.0",
+  description: "Lobe-UI \u98CE\u683C\u54CD\u5E94\u5F0F\u4E3B\u9898\u7CFB\u7EDF\u63D2\u4EF6",
+  setup(context) {
+    const {
+      darkMode = true,
+      defaultAppearance = "light",
+      primaryColor,
+      neutralColor,
+      prefixCls = "ant",
+      cssVar = true,
+      globalReset = true,
+      externalTheme = false,
+      locale = "auto",
+      scopePopupContainer = true
+    } = options;
+    const { logger } = context;
+    logger.info(
+      `\u4E3B\u9898\u6A21\u5F0F: ${defaultAppearance}, \u4E3B\u8272: ${primaryColor ?? "primary(\u9ED8\u8BA4\u9ED1)"}, \u54CD\u5E94\u5F0F: \u2713`
+    );
+    const hooks = {
+      modifyRspackConfig(config, ctx) {
+        const themePath = join6(ctx.cwd, ".ywkf", "theme.tsx");
+        const currentAlias = config.resolve?.alias ?? {};
+        config.resolve = {
+          ...config.resolve,
+          alias: {
+            ...currentAlias,
+            "@ywkf/theme": themePath
+          }
+        };
+        return config;
+      },
+      generateFiles(_ctx) {
+        return [
+          {
+            path: "theme.tsx",
+            content: generateThemeProvider({
+              darkMode,
+              defaultAppearance,
+              primaryColor,
+              neutralColor,
+              prefixCls,
+              cssVar,
+              globalReset,
+              externalTheme,
+              locale,
+              scopePopupContainer
+            })
+          }
+        ];
+      },
+      injectBootstrap(_ctx) {
+        return {
+          imports: [`import { ThemeWrapper } from "./theme";`]
+        };
+      },
+      modifyBootstrapCode(code) {
+        const providerEntry = `    {
+      component: ThemeWrapper as React.ComponentType<{ children: React.ReactNode }>,
+      props: {},
+      order: 10,
+    }`;
+        if (code.includes("providers: []")) {
+          code = code.replace(
+            "providers: []",
+            `providers: [
+${providerEntry},
+  ]`
+          );
+        } else if (code.includes("providers: [")) {
+          code = code.replace(
+            "providers: [",
+            `providers: [
+${providerEntry},`
+          );
+        }
+        if (!code.includes("import React")) {
+          code = code.replace(
+            `import { bootstrap`,
+            `import React from "react";
+import { bootstrap`
+          );
+        }
+        return code;
+      }
+    };
+    return hooks;
+  }
+}));
+function generateThemeProvider(opts) {
+  const {
+    darkMode,
+    defaultAppearance,
+    primaryColor,
+    neutralColor,
+    prefixCls,
+    cssVar,
+    globalReset,
+    externalTheme,
+    locale,
+    scopePopupContainer
+  } = opts;
+  const isAutoLocale = locale === "auto";
+  const sections = [];
+  sections.push(`// \u6B64\u6587\u4EF6\u7531 @4399ywkf/plugin-theme v3 \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u4FEE\u6539`);
+  sections.push(buildImports({ globalReset, cssVar, scopePopupContainer, locale }));
+  sections.push(TYPES_CODE);
+  sections.push(
+    buildStoreCode({ defaultAppearance, primaryColor, neutralColor, locale })
+  );
+  sections.push(HOOKS_CODE);
+  if (globalReset) sections.push(GLOBAL_RESET_CODE);
+  if (cssVar) sections.push(buildCssVarSyncCode());
+  if (darkMode) sections.push(APPEARANCE_SYNC_CODE);
+  if (externalTheme) sections.push(EXTERNAL_THEME_CODE);
+  if (isAutoLocale) sections.push(LOCALE_AUTO_CODE);
+  sections.push(
+    buildWrapperCode({
+      darkMode,
+      cssVar,
+      globalReset,
+      externalTheme,
+      locale,
+      prefixCls,
+      scopePopupContainer
+    })
+  );
+  return sections.join("\n");
+}
+var ANTD_LOCALE_MAP = {
+  zhCN: { importName: "zhCN", importPath: "antd/locale/zh_CN.js" },
+  enUS: { importName: "enUS", importPath: "antd/locale/en_US.js" },
+  zhTW: { importName: "zhTW", importPath: "antd/locale/zh_TW.js" },
+  jaJP: { importName: "jaJP", importPath: "antd/locale/ja_JP.js" },
+  koKR: { importName: "koKR", importPath: "antd/locale/ko_KR.js" }
+};
+var LOCALE_TO_BCP47 = {
+  zhCN: "zh-CN",
+  enUS: "en-US",
+  zhTW: "zh-TW",
+  jaJP: "ja-JP",
+  koKR: "ko-KR"
+};
+function buildImports(opts) {
+  const needsRef = opts.cssVar || opts.scopePopupContainer;
+  const isAutoLocale = opts.locale === "auto";
+  const reactImports = [
+    "useCallback",
+    "useEffect",
+    "useMemo",
+    "useState",
+    ...opts.cssVar ? ["useLayoutEffect"] : [],
+    ...needsRef ? ["useRef"] : [],
+    "type ReactNode"
+  ];
+  const antdStyleImports = [
+    "ThemeProvider as AntdThemeProvider",
+    "StyleProvider",
+    "type GetAntdTheme",
+    ...opts.globalReset ? ["createGlobalStyle", "css"] : []
+  ];
+  const localeEntry = ANTD_LOCALE_MAP[opts.locale];
+  const localeImports = isAutoLocale ? `import zhCN from "antd/locale/zh_CN.js";
+import type { Locale as AntdLocale } from "antd/es/locale";` : localeEntry ? `import ${localeEntry.importName} from "${localeEntry.importPath}";` : `import zhCN from "antd/locale/zh_CN.js";`;
+  return `
+import React, { ${reactImports.join(", ")} } from "react";
+import { ConfigProvider } from "antd";
+${localeImports}
+import { ${antdStyleImports.join(", ")} } from "antd-style";
+import { createWithEqualityFn } from "zustand/traditional";
+import { shallow } from "zustand/shallow";
+import { createThemeConfig, type PrimaryColors, type NeutralColors } from "@4399ywkf/theme-system";`;
+}
+var TYPES_CODE = `
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 Types \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+export type ThemeAppearance = "light" | "dark" | "auto";
+
+export interface ThemeState {
+  appearance: ThemeAppearance;
+  primaryColor?: PrimaryColors;
+  neutralColor?: NeutralColors;
+  /** BCP 47 language tag, e.g. "zh-CN", "en-US" */
+  locale: string;
+}
+
+export interface ThemeActions {
+  setAppearance: (mode: ThemeAppearance) => void;
+  setPrimaryColor: (color: PrimaryColors | undefined) => void;
+  setNeutralColor: (color: NeutralColors | undefined) => void;
+  setLocale: (locale: string) => void;
+  setTheme: (partial: Partial<ThemeState>) => void;
+}
+
+export type ThemeStore = ThemeState & ThemeActions;
+
+export type { PrimaryColors, NeutralColors };`;
+function buildStoreCode(opts) {
+  const isAutoLocale = opts.locale === "auto";
+  const primaryLine = opts.primaryColor ? `  primaryColor: "${opts.primaryColor}" as PrimaryColors,` : `  primaryColor: undefined,`;
+  const neutralLine = opts.neutralColor ? `  neutralColor: "${opts.neutralColor}" as NeutralColors,` : `  neutralColor: undefined,`;
+  const localeLine = isAutoLocale ? `  locale: detectInitialLocale(),` : `  locale: "${LOCALE_TO_BCP47[opts.locale] ?? "zh-CN"}",`;
+  const detectionFn = isAutoLocale ? `
+function detectInitialLocale(): string {
+  if (typeof window !== "undefined") {
+    const hostLocale = (window as any).__YWKF_LOCALE__;
+    if (typeof hostLocale === "string" && hostLocale) return hostLocale;
+  }
+  if (typeof navigator !== "undefined") {
+    return navigator.language || "zh-CN";
+  }
+  return "zh-CN";
+}
+` : "";
+  return `
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 Theme Store \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+${detectionFn}
+const DEFAULT_THEME: ThemeState = {
+  appearance: "${opts.defaultAppearance}",
+${primaryLine}
+${neutralLine}
+${localeLine}
+};
+
+export const useThemeStore = createWithEqualityFn<ThemeStore>()(
+  (set) => ({
+    ...DEFAULT_THEME,
+    setAppearance: (mode) => set({ appearance: mode }),
+    setPrimaryColor: (color) => set({ primaryColor: color }),
+    setNeutralColor: (color) => set({ neutralColor: color }),
+    setLocale: (locale) => set({ locale }),
+    setTheme: (partial) => set(partial),
+  }),
+  shallow,
+);`;
+}
+var HOOKS_CODE = `
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 Convenience Hooks \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+export const useTheme = () =>
+  useThemeStore(
+    (s) => ({
+      appearance: s.appearance,
+      primaryColor: s.primaryColor,
+      neutralColor: s.neutralColor,
+    }),
+    shallow,
+  );
+
+export const useAppearance = () => useThemeStore((s) => s.appearance);
+export const usePrimaryColor = () => useThemeStore((s) => s.primaryColor);
+export const useLocale = () => useThemeStore((s) => s.locale);`;
+var GLOBAL_RESET_CODE = `
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 Global Style \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+const GlobalReset = createGlobalStyle(({ theme }) => css\`
+  :root {
+    --font-settings: "cv01", "tnum", "kern";
+    --font-variations: "opsz" auto, tabular-nums;
+  }
+
+  *,
+  *::before,
+  *::after {
+    box-sizing: border-box;
+    vertical-align: baseline;
+  }
+
+  * {
+    scrollbar-color: \${theme.colorFill} transparent;
+    scrollbar-width: thin;
+  }
+
+  html {
+    overscroll-behavior: none;
+    color-scheme: \${theme.isDarkMode ? "dark" : "light"};
+  }
+
+  html, body, #root, #app {
+    height: 100%;
+    margin: 0;
+    padding: 0;
+  }
+
+  body {
+    overflow: hidden auto;
+    min-height: 100vh;
+    font-family: \${theme.fontFamily};
+    font-size: \${theme.fontSize}px;
+    font-feature-settings: var(--font-settings);
+    font-variation-settings: var(--font-variations);
+    line-height: 1;
+    color: \${theme.colorTextBase};
+    text-size-adjust: none;
+    text-rendering: optimizelegibility;
+    word-wrap: break-word;
+    background-color: \${theme.colorBgLayout};
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+    -webkit-overflow-scrolling: touch;
+    -webkit-tap-highlight-color: transparent;
+  }
+
+  code {
+    font-family: \${theme.fontFamilyCode} !important;
+  }
+
+  ::selection {
+    -webkit-text-fill-color: unset !important;
+  }
+\`);`;
+function buildCssVarSyncCode() {
+  return `
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 CSS Variable Sync \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+const CSS_VAR_CLASS_RE = /(^|-)css-var(-|$)/;
+
+function isCssVarClassName(className: string): boolean {
+  return CSS_VAR_CLASS_RE.test(className);
+}
+
+function useCssVarSync(ref: React.RefObject<HTMLDivElement | null>) {
+  useLayoutEffect(() => {
+    const node = ref.current;
+    if (!node) return;
+
+    const htmlEl = document.documentElement;
+    let currentClasses: string[] = [];
+
+    const sync = () => {
+      for (const cls of currentClasses) {
+        htmlEl.classList.remove(cls);
+      }
+
+      const nextSet = new Set<string>();
+      let el: HTMLElement | null = node;
+
+      while (el && el !== htmlEl) {
+        for (const cls of el.classList) {
+          if (isCssVarClassName(cls)) {
+            nextSet.add(cls);
+          }
+        }
+        el = el.parentElement;
+      }
+
+      const next = Array.from(nextSet);
+
+      for (const cls of next) {
+        htmlEl.classList.add(cls);
+      }
+
+      currentClasses = next;
+    };
+
+    sync();
+
+    const observer = new MutationObserver(sync);
+    let el: HTMLElement | null = node;
+    while (el && el !== htmlEl) {
+      observer.observe(el, { attributeFilter: ["class"] });
+      el = el.parentElement;
+    }
+
+    return () => {
+      observer.disconnect();
+      for (const cls of currentClasses) {
+        htmlEl.classList.remove(cls);
+      }
+    };
+  }, []);
+}`;
+}
+var APPEARANCE_SYNC_CODE = `
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 Appearance Sync \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+function useAppearanceSync(appearance: ThemeAppearance) {
+  useEffect(() => {
+    if (appearance !== "auto") {
+      document.documentElement.dataset.theme = appearance;
+      return;
+    }
+
+    const mq = window.matchMedia("(prefers-color-scheme: dark)");
+    document.documentElement.dataset.theme = mq.matches ? "dark" : "light";
+
+    function handleChange(e: MediaQueryListEvent) {
+      document.documentElement.dataset.theme = e.matches ? "dark" : "light";
+    }
+
+    mq.addEventListener("change", handleChange);
+    return () => mq.removeEventListener("change", handleChange);
+  }, [appearance]);
+}`;
+var EXTERNAL_THEME_CODE = `
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 External Theme Injection \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+function useExternalTheme() {
+  useEffect(() => {
+    const hostTheme = (window as any).__YWKF_THEME__;
+    if (hostTheme && typeof hostTheme === "object") {
+      useThemeStore.getState().setTheme(hostTheme);
+    }
+
+    const handler = (e: Event) => {
+      const detail = (e as CustomEvent<Partial<ThemeState>>).detail;
+      if (detail) useThemeStore.getState().setTheme(detail);
+    };
+
+    window.addEventListener("ywkf:theme-change", handler);
+    return () => window.removeEventListener("ywkf:theme-change", handler);
+  }, []);
+}`;
+var LOCALE_AUTO_CODE = `
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 Locale Runtime Management \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+const ANTD_LOCALE_LOADERS: Record<string, () => Promise<{ default: AntdLocale }>> = {
+  en: () => import("antd/locale/en_US.js"),
+  "zh-tw": () => import("antd/locale/zh_TW.js"),
+  "zh-hk": () => import("antd/locale/zh_TW.js"),
+  ja: () => import("antd/locale/ja_JP.js"),
+  ko: () => import("antd/locale/ko_KR.js"),
+};
+
+function useAntdLocale(): AntdLocale {
+  const lang = useThemeStore((s) => s.locale);
+  const [antdLocale, setAntdLocale] = useState<AntdLocale>(zhCN);
+
+  useEffect(() => {
+    const normalized = (lang || "zh-CN").toLowerCase();
+
+    if (normalized === "zh" || normalized === "zh-cn") {
+      setAntdLocale(zhCN);
+      return;
+    }
+
+    const loader =
+      ANTD_LOCALE_LOADERS[normalized] ??
+      ANTD_LOCALE_LOADERS[normalized.split("-")[0]];
+
+    if (loader) {
+      let cancelled = false;
+      loader().then((m) => {
+        if (!cancelled) setAntdLocale(m.default);
+      });
+      return () => { cancelled = true; };
+    }
+
+    setAntdLocale(zhCN);
+  }, [lang]);
+
+  return antdLocale;
+}
+
+function useExternalLocale() {
+  useEffect(() => {
+    const handler = (e: Event) => {
+      const locale = (e as CustomEvent<string>).detail;
+      if (typeof locale === "string" && locale) {
+        useThemeStore.getState().setLocale(locale);
+      }
+    };
+
+    window.addEventListener("ywkf:locale-change", handler);
+    return () => window.removeEventListener("ywkf:locale-change", handler);
+  }, []);
+}`;
+function buildWrapperCode(opts) {
+  const { darkMode, cssVar, globalReset, externalTheme, locale, prefixCls, scopePopupContainer } = opts;
+  const cssVarRefLine = cssVar ? "\n  const containerRef = useRef<HTMLDivElement>(null);" : "";
+  const popupRefLine = scopePopupContainer ? "\n  const popupContainerRef = useRef<HTMLDivElement>(null);" : "";
+  const cssVarSyncLine = cssVar ? "\n  useCssVarSync(containerRef);" : "";
+  const appearanceSyncLine = darkMode ? "\n  useAppearanceSync(appearance);" : "";
+  const externalThemeLine = externalTheme ? "\n  useExternalTheme();" : "";
+  const isAutoLocale = locale === "auto";
+  const localeEntry = ANTD_LOCALE_MAP[locale];
+  const localeVarName = isAutoLocale ? "antdLocale" : localeEntry?.importName ?? "zhCN";
+  const localeLine = isAutoLocale ? "\n  const antdLocale = useAntdLocale();\n  useExternalLocale();" : "";
+  const getPopupContainerLine = scopePopupContainer ? `
+  // \u5C06\u5F39\u5C42\u6302\u8F7D\u5230\u5BB9\u5668\u5185\u90E8\uFF0C\u786E\u4FDD\u80FD\u7EE7\u627F StyleProvider \u6CE8\u5165\u7684\u6837\u5F0F\u4E0E CSS \u53D8\u91CF\u3002
+  // \u5FAE\u524D\u7AEF\u6A21\u5F0F\u4E0B\u4F18\u5148\u4F7F\u7528 styleContainer\uFF08\u5B50\u5E94\u7528\u6839\u5BB9\u5668\uFF09\uFF0C
+  // \u666E\u901A\u6A21\u5F0F\u4E0B\u4F7F\u7528 popupContainerRef \u6240\u6307\u5411\u7684\u5305\u88C5 div\u3002
+  const getPopupContainer = useCallback(
+    (): HTMLElement =>
+      (IS_MICRO_APP ? styleContainer : popupContainerRef.current) ?? document.body,
+    [styleContainer],
+  );` : "";
+  const childrenSlot = cssVar ? `<div ref={containerRef} style={{ display: "contents" }}>
+        {children}
+      </div>` : "{children}";
+  const innerContent = scopePopupContainer ? `<ConfigProvider locale={${localeVarName}} getPopupContainer={getPopupContainer}>
+      ${globalReset ? "<GlobalReset />" : ""}
+      ${childrenSlot}
+    </ConfigProvider>` : `<ConfigProvider locale={${localeVarName}}>
+      ${globalReset ? "<GlobalReset />" : ""}
+      ${childrenSlot}
+    </ConfigProvider>`;
+  const antdProvider = `<AntdThemeProvider
+      prefixCls={RUNTIME_PREFIX_CLS}
+      appearance={resolvedAppearance}
+      themeMode={appearance}
+      theme={theme}${cssVar ? "\n      customToken={{ cssVar: true }}" : ""}
+    >
+      ${innerContent}
+    </AntdThemeProvider>`;
+  const wrapperOpen = scopePopupContainer ? `<div
+    ref={popupContainerRef}
+    data-ywkf-root
+    style={{ position: "relative", height: "100%" }}
+  >` : "";
+  const wrapperClose = scopePopupContainer ? `</div>` : "";
+  const innerReturn = `IS_MICRO_APP && styleContainer ? (
+    <StyleProvider container={styleContainer}>{provider}</StyleProvider>
+  ) : provider`;
+  const returnBody = scopePopupContainer ? `(
+    ${wrapperOpen}
+      {IS_MICRO_APP && styleContainer ? (
+        <StyleProvider container={styleContainer}>{provider}</StyleProvider>
+      ) : provider}
+    ${wrapperClose}
+  )` : `(${innerReturn})`;
+  return `
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 ThemeWrapper \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+// \u8FD0\u884C\u65F6\u5224\u65AD\u662F\u5426\u5904\u4E8E Garfish \u5B50\u5E94\u7528\u73AF\u5883\uFF0C\u540C\u4E00 bundle \u652F\u6301\u72EC\u7ACB\u90E8\u7F72\u4E0E\u5FAE\u524D\u7AEF\u4E24\u79CD\u6A21\u5F0F\u3002
+const IS_MICRO_APP = typeof window !== "undefined" && !!(window as any).__GARFISH__;
+
+const RUNTIME_PREFIX_CLS = typeof process !== "undefined"
+  && process.env?.YWKF_PREFIX_CLS
+  || "${prefixCls}";
+
+interface ThemeWrapperProps {
+  children: ReactNode;
+}
+
+export function ThemeWrapper({ children }: ThemeWrapperProps) {${cssVarRefLine}${popupRefLine}
+  const { appearance, primaryColor, neutralColor } = useThemeStore(
+    (s) => ({ appearance: s.appearance, primaryColor: s.primaryColor, neutralColor: s.neutralColor }),
+    shallow,
+  );${cssVarSyncLine}${appearanceSyncLine}${externalThemeLine}${localeLine}
+
+  // \u5FAE\u524D\u7AEF\u6A21\u5F0F\u4E0B\uFF0C\u5C06 CSS-in-JS \u6837\u5F0F\u6CE8\u5165\u5230 Garfish \u5B50\u5E94\u7528\u5BB9\u5668\u800C\u975E document.head\uFF0C
+  // \u907F\u514D\u4E0E\u4E3B\u5E94\u7528\u5171\u4EAB\u7684 @ant-design/cssinjs StyleContext \u4EA7\u751F\u51B2\u7A81\u3002
+  // useState lazy initializer \u540C\u6B65\u8BFB\u53D6\uFF08Garfish \u6302\u8F7D\u65F6\u5BB9\u5668\u5DF2\u63D0\u524D\u521B\u5EFA\uFF09\uFF0C
+  // useEffect \u515C\u5E95\u5904\u7406\u6781\u7AEF\u7ADE\u6001\uFF08\u5982 SSR hydration\uFF09\u3002
+  const [styleContainer, setStyleContainer] = useState<HTMLElement | undefined>(() => {
+    if (!IS_MICRO_APP || typeof document === "undefined") return undefined;
+    return document.getElementById(RUNTIME_PREFIX_CLS)?.parentElement ?? undefined;
+  });
+
+  useEffect(() => {
+    if (!IS_MICRO_APP) return;
+    const el = document.getElementById(RUNTIME_PREFIX_CLS)?.parentElement;
+    if (el) setStyleContainer(el);
+  }, []);
+
+  const resolvedAppearance = useMemo(() => {
+    if (appearance !== "auto") return appearance;
+    if (typeof window === "undefined") return "light";
+    return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+  }, [appearance]);
+
+  const theme = useCallback<GetAntdTheme>(
+    (ap) => createThemeConfig({
+      appearance: ap as "light" | "dark",
+      primaryColor,
+      neutralColor,
+    }),
+    [primaryColor, neutralColor],
+  );
+${getPopupContainerLine}
+  const provider = (
+    ${antdProvider}
+  );
+
+  return ${returnBody};
+}
+
+export default ThemeWrapper;
+`;
+}
+
+// src/plugin/builtin/zustand.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7 } from "path";
+var zustandPlugin = createPlugin((options = {}) => ({
+  name: "@4399ywkf/plugin-zustand",
+  version: "1.0.0",
+  description: "Zustand \u72B6\u6001\u7BA1\u7406\u96C6\u6210",
+  setup(context) {
+    const { scaffold = true, storeDir = "store" } = options;
+    const { cwd, logger } = context;
+    const storePath = join7(cwd, storeDir);
+    if (scaffold && !existsSync6(storePath)) {
+      scaffoldStore(storePath, logger);
+    }
+    const hooks = {
+      modifyRspackConfig(rspackConfig) {
+        logger.info("Zustand \u5DF2\u542F\u7528");
+        const resolve4 = rspackConfig.resolve || {};
+        const alias = resolve4.alias || {};
+        alias["@store"] = storePath;
+        resolve4.alias = alias;
+        rspackConfig.resolve = resolve4;
+        return rspackConfig;
+      },
+      generateFiles(_ctx) {
+        return [
+          {
+            path: "store.ts",
+            content: buildStoreHelperFile()
+          }
+        ];
+      }
+    };
+    return hooks;
+  }
+}));
+function scaffoldStore(storePath, logger) {
+  const dirs = [
+    storePath,
+    join7(storePath, "middleware"),
+    join7(storePath, "app"),
+    join7(storePath, "app", "slices"),
+    join7(storePath, "app", "slices", "counter")
+  ];
+  for (const dir of dirs) {
+    if (!existsSync6(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+  }
+  writeFileSync4(join7(storePath, "middleware", "createDevtools.ts"), TPL_CREATE_DEVTOOLS, "utf-8");
+  writeFileSync4(
+    join7(storePath, "app", "slices", "counter", "initialState.ts"),
+    TPL_COUNTER_INITIAL_STATE,
+    "utf-8"
+  );
+  writeFileSync4(
+    join7(storePath, "app", "slices", "counter", "actions.ts"),
+    TPL_COUNTER_ACTIONS,
+    "utf-8"
+  );
+  writeFileSync4(join7(storePath, "app", "initialState.ts"), TPL_APP_INITIAL_STATE, "utf-8");
+  writeFileSync4(join7(storePath, "app", "store.ts"), TPL_APP_STORE, "utf-8");
+  writeFileSync4(join7(storePath, "app", "index.tsx"), TPL_APP_INDEX, "utf-8");
+  writeFileSync4(join7(storePath, "index.ts"), TPL_STORE_INDEX, "utf-8");
+  logger.info("\u5DF2\u751F\u6210 store/ \u811A\u624B\u67B6\uFF08Agent/Slice \u67B6\u6784\uFF09");
+}
+var TPL_CREATE_DEVTOOLS = `import type { DevtoolsOptions } from "zustand/middleware";
+import { devtools as devtoolsMiddleware } from "zustand/middleware";
+import type { StateCreator, StoreMutatorIdentifier } from "zustand/vanilla";
+
+/**
+ * \u5C01\u88C5 zustand devtools \u4E2D\u95F4\u4EF6
+ * \u751F\u4EA7\u73AF\u5883\u81EA\u52A8\u7981\u7528\uFF0C\u5F00\u53D1\u73AF\u5883\u542F\u7528 trace
+ */
+export const createDevtools =
+  (name: string, options?: DevtoolsOptions) =>
+  <
+    T,
+    Mps extends [StoreMutatorIdentifier, unknown][] = [],
+    Mcs extends [StoreMutatorIdentifier, unknown][] = [],
+  >(
+    initializer: StateCreator<T, [...Mps, ["zustand/devtools", never]], Mcs>,
+  ) =>
+    devtoolsMiddleware(initializer, {
+      name,
+      enabled: process.env.NODE_ENV === "development",
+      trace: process.env.NODE_ENV === "development",
+      ...options,
+    });
+`;
+var TPL_COUNTER_INITIAL_STATE = `export interface CounterState {
+  count: number;
+  loading: boolean;
+  error: string | null;
+}
+
+export const initialCounterState: CounterState = {
+  count: 0,
+  loading: false,
+  error: null,
+};
+`;
+var TPL_COUNTER_ACTIONS = `import type { StateCreator } from "zustand/vanilla";
+import type { AppStore } from "../../store";
+
+export interface CounterAction {
+  increment: () => void;
+  decrement: () => void;
+  reset: () => void;
+  setLoading: (loading: boolean) => void;
+  setError: (error: string | null) => void;
+  fetchCount: () => Promise<void>;
+}
+
+export const createCounterSlice: StateCreator<
+  AppStore,
+  [["zustand/devtools", never]],
+  [],
+  CounterAction
+> = (set, get) => ({
+  increment: () => set((s) => ({ count: s.count + 1 })),
+  decrement: () => set((s) => ({ count: s.count - 1 })),
+  reset: () => set({ count: 0, error: null }),
+  setLoading: (loading) => set({ loading }),
+  setError: (error) => set({ error }),
+
+  fetchCount: async () => {
+    set({ loading: true, error: null });
+    try {
+      // \u66FF\u6362\u4E3A\u5B9E\u9645 API \u8C03\u7528
+      // import request from "@ywkf/request";
+      // const res = await request.get("/api/count");
+      // set({ count: res.data, loading: false });
+      await new Promise((r) => setTimeout(r, 500));
+      set({ count: 42, loading: false });
+    } catch (err) {
+      set({
+        error: err instanceof Error ? err.message : "\u672A\u77E5\u9519\u8BEF",
+        loading: false,
+      });
+    }
+  },
+});
+`;
+var TPL_APP_INITIAL_STATE = `import {
+  type CounterState,
+  initialCounterState,
+} from "./slices/counter/initialState";
+
+// ============== \u805A\u5408\u6240\u6709 Slice \u72B6\u6001 ============== //
+
+export type AppStoreState = CounterState;
+
+export const initialState: AppStoreState = {
+  ...initialCounterState,
+};
+`;
+var TPL_APP_STORE = `import { subscribeWithSelector } from "zustand/middleware";
+import { shallow } from "zustand/shallow";
+import { createWithEqualityFn } from "zustand/traditional";
+import type { StateCreator } from "zustand/vanilla";
+
+import { createDevtools } from "../middleware/createDevtools";
+import { type AppStoreState, initialState } from "./initialState";
+
+import {
+  type CounterAction,
+  createCounterSlice,
+} from "./slices/counter/actions";
+
+// ============== \u805A\u5408 Store \u7C7B\u578B ============== //
+
+export type AppStore = AppStoreState & CounterAction;
+
+// ============== \u521B\u5EFA Store ============== //
+
+const createStore: StateCreator<AppStore, [["zustand/devtools", never]]> = (
+  ...parameters
+) => ({
+  ...initialState,
+  ...createCounterSlice(...parameters),
+});
+
+// ============== \u5B9E\u88C5 useStore ============== //
+
+const devtools = createDevtools("app");
+
+export const useAppStore = createWithEqualityFn<AppStore>()(
+  subscribeWithSelector(devtools(createStore)),
+  shallow,
+);
+
+export const getAppStoreState = () => useAppStore.getState();
+`;
+var TPL_APP_INDEX = `export { useAppStore, getAppStoreState } from "./store";
+export type { AppStore } from "./store";
+export { initialState } from "./initialState";
+export type { AppStoreState } from "./initialState";
+`;
+var TPL_STORE_INDEX = `/**
+ * Store \u805A\u5408\u5165\u53E3
+ *
+ * \u67B6\u6784\uFF1A
+ * - store/middleware/     \u2014 \u4E2D\u95F4\u4EF6\uFF08devtools \u7B49\uFF09
+ * - store/{domain}/       \u2014 \u6BCF\u4E2A\u57DF\u4EE3\u8868\u4E00\u4E2A\u4E1A\u52A1\u5B50\u7CFB\u7EDF
+ * - store/{domain}/slices \u2014 \u6BCF\u4E2A slice \u62C6\u4E3A initialState + actions
+ *
+ * \u7EA6\u675F\uFF1A
+ * - initialState\uFF1A\u7EAF\u6570\u636E\u5B9A\u4E49\uFF0C\u4E0D\u542B\u903B\u8F91
+ * - actions\uFF1A\u540C\u6B65\u72B6\u6001\u53D8\u66F4 + \u5F02\u6B65\u526F\u4F5C\u7528
+ * - slice \u4E4B\u95F4\u7981\u6B62\u76F4\u63A5\u4FEE\u6539\u5F7C\u6B64\u72B6\u6001
+ * - \u57DF\u5C42\u8D1F\u8D23\u8DE8 slice \u534F\u8C03
+ */
+export { useAppStore, getAppStoreState } from "./app";
+export type { AppStore, AppStoreState } from "./app";
+`;
+function buildStoreHelperFile() {
+  return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/plugin-zustand \u81EA\u52A8\u751F\u6210
+// \u63D0\u4F9B Zustand \u5DE5\u5177\u51FD\u6570\u7684 re-export\uFF0C\u65B9\u4FBF\u4E1A\u52A1\u4EE3\u7801\u5F15\u7528
+
+export { useShallow } from "zustand/react/shallow";
+export type { StateCreator, StoreApi } from "zustand";
+`;
+}
+
+// src/config/normalize.ts
+var BUILTIN_PLUGINS = [
+  { key: "reactQuery", factory: reactQueryPlugin, pluginName: "@4399ywkf/plugin-react-query" },
+  { key: "zustand", factory: zustandPlugin, pluginName: "@4399ywkf/plugin-zustand" },
+  { key: "tailwind", factory: tailwindPlugin, pluginName: "@4399ywkf/plugin-tailwind" }
+];
+var OPTIONAL_PLUGINS = [
+  { key: "biome", factory: biomePlugin, pluginName: "@4399ywkf/plugin-biome" },
+  { key: "analytics", factory: analyticsPlugin, pluginName: "@4399ywkf/plugin-analytics" },
+  { key: "mock", factory: mockPlugin, pluginName: "@4399ywkf/plugin-mock" },
+  { key: "theme", factory: themePlugin, pluginName: "@4399ywkf/plugin-theme" },
+  { key: "i18n", factory: i18nPlugin, pluginName: "@4399ywkf/plugin-i18n" },
+  { key: "garfish", factory: garfishPlugin, pluginName: "@4399ywkf/plugin-garfish" },
+  { key: "browserCheck", factory: browserCheckPlugin, pluginName: "@4399ywkf/plugin-browser-check" }
+];
+var ALL_SHORTHAND_KEYS = /* @__PURE__ */ new Set([
+  ...BUILTIN_PLUGINS.map((p) => p.key),
+  ...OPTIONAL_PLUGINS.map((p) => p.key)
+]);
+function normalizeConfig(input) {
+  const raw = input;
+  const result = { ...raw };
+  const hasShorthands = hasAnyShorthand(result);
+  if (!hasShorthands) {
+    return input;
+  }
+  inferFields(result);
+  const plugins = result.plugins;
+  const explicitPlugins = plugins ?? [];
+  const explicitNames = collectPluginNames(explicitPlugins);
+  const shorthandPlugins = [];
+  for (const { key, factory, pluginName } of BUILTIN_PLUGINS) {
+    const value = result[key];
+    if (explicitNames.has(pluginName)) continue;
+    if (value === false) continue;
+    if (value === void 0 && !hasShorthands) continue;
+    const opts = typeof value === "object" ? value : void 0;
+    shorthandPlugins.push(factory(opts));
+  }
+  for (const { key, factory, pluginName } of OPTIONAL_PLUGINS) {
+    const value = result[key];
+    if (value === void 0 || explicitNames.has(pluginName)) continue;
+    const opts = value === true ? void 0 : value;
+    shorthandPlugins.push(factory(opts));
+  }
+  result.plugins = [...shorthandPlugins, ...explicitPlugins];
+  for (const key of ALL_SHORTHAND_KEYS) {
+    delete result[key];
+  }
+  return result;
+}
+function inferFields(config) {
+  const html = config.html ?? {};
+  config.html = html;
+  if (html.title === void 0 && config.appCName) {
+    html.title = config.appCName;
+  }
+  if (html.mountRoot === void 0 && config.appName) {
+    html.mountRoot = config.appName;
+  }
+}
+function hasAnyShorthand(config) {
+  for (const key of ALL_SHORTHAND_KEYS) {
+    if (config[key] !== void 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function collectPluginNames(plugins) {
+  const names = /* @__PURE__ */ new Set();
+  for (const p of plugins) {
+    if (typeof p === "object" && p !== null && "name" in p) {
+      names.add(p.name);
+    }
+  }
+  return names;
+}
 
 // src/config/schema.ts
 var defaultConfig = {
@@ -80,8 +2196,8 @@ var defaultConfig = {
 var CONFIG_FILES = ["ywkf.config.ts", "ywkf.config.mts", "ywkf.config.js", "ywkf.config.mjs"];
 function findConfigFile(cwd) {
   for (const file of CONFIG_FILES) {
-    const configPath = resolve(cwd, file);
-    if (existsSync(configPath)) {
+    const configPath = resolve2(cwd, file);
+    if (existsSync7(configPath)) {
       return configPath;
     }
   }
@@ -123,7 +2239,8 @@ async function resolveConfig(cwd) {
   }
   try {
     const userConfig = await loadConfigFile(configPath);
-    const config = mergeConfig(userConfig);
+    const normalized = normalizeConfig(userConfig);
+    const config = mergeConfig(normalized);
     return { config, configPath };
   } catch (error) {
     console.error("\u274C \u914D\u7F6E\u6587\u4EF6\u52A0\u8F7D\u5931\u8D25:", error);
@@ -132,7 +2249,7 @@ async function resolveConfig(cwd) {
 }
 function createPathResolver(cwd) {
   return {
-    resolveApp: (relativePath) => resolve(cwd, relativePath),
+    resolveApp: (relativePath) => resolve2(cwd, relativePath),
     cwd
   };
 }
@@ -374,21 +2491,21 @@ import { merge } from "webpack-merge";
 
 // src/rspack/base.ts
 import { createRequire } from "module";
-import { dirname, join as join5 } from "path";
+import { dirname, join as join12 } from "path";
 import { fileURLToPath } from "url";
-import { rspack } from "@rspack/core";
+import { rspack as rspack2 } from "@rspack/core";
 
 // src/generator/plugin.ts
-import { existsSync as existsSync5, watch } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync11, watch } from "fs";
+import { join as join11 } from "path";
 
 // src/generator/generator.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
+import { join as join10 } from "path";
 
 // src/router/generator.ts
-import { existsSync as existsSync2, mkdirSync, readdirSync, statSync, writeFileSync } from "fs";
-import { join, relative } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
+import { join as join8, relative } from "path";
 function winPath(path) {
   const isExtendedLengthPath = /^\\\\\?\\/.test(path);
   if (isExtendedLengthPath) {
@@ -421,7 +2538,7 @@ var ConventionalRouteGenerator = class {
   }
   generate() {
     const { pagesDir } = this.options;
-    if (!existsSync2(pagesDir)) {
+    if (!existsSync8(pagesDir)) {
       console.warn(`[ywkf] \u9875\u9762\u76EE\u5F55\u4E0D\u5B58\u5728: ${pagesDir}`);
       return [];
     }
@@ -431,7 +2548,7 @@ var ConventionalRouteGenerator = class {
    * 扫描目录，生成路由树
    */
   scanDirectory(dir, routePath) {
-    const entries = readdirSync(dir);
+    const entries = readdirSync2(dir);
     const layoutFile = entries.find((e) => CONVENTION_FILES.layout.test(e));
     const pageFile = entries.find((e) => CONVENTION_FILES.page.test(e));
     const errorFile = entries.find((e) => CONVENTION_FILES.error.test(e));
@@ -440,18 +2557,18 @@ var ConventionalRouteGenerator = class {
     const subDirs = entries.filter((e) => {
       if (e.startsWith(".")) return false;
       if (EXCLUDED_DIRS.has(e)) return false;
-      return statSync(join(dir, e)).isDirectory();
+      return statSync2(join8(dir, e)).isDirectory();
     });
     const childRoutes = [];
     for (const subDir of subDirs) {
-      const subDirPath = join(dir, subDir);
+      const subDirPath = join8(dir, subDir);
       if (subDir.startsWith("__")) {
         const pathlessRoutes = this.scanDirectory(subDirPath, routePath);
-        const pathlessLayout = readdirSync(subDirPath).find((e) => CONVENTION_FILES.layout.test(e));
+        const pathlessLayout = readdirSync2(subDirPath).find((e) => CONVENTION_FILES.layout.test(e));
         if (pathlessLayout) {
           const pathlessChildren = this.scanDirectory(subDirPath, routePath);
           const pathlessLayoutRel = winPath(
-            relative(this.options.pagesDir, join(subDirPath, pathlessLayout))
+            relative(this.options.pagesDir, join8(subDirPath, pathlessLayout))
           );
           childRoutes.push({
             path: routePath,
@@ -470,7 +2587,7 @@ var ConventionalRouteGenerator = class {
       childRoutes.push(...this.scanDirectory(subDirPath, subRoutePath));
     }
     const routeName = this.generateRouteName(routePath);
-    const relPath = (file) => winPath(relative(this.options.pagesDir, join(dir, file)));
+    const relPath = (file) => winPath(relative(this.options.pagesDir, join8(dir, file)));
     if (layoutFile) {
       const layoutChildren = [];
       if (pageFile) {
@@ -728,10 +2845,10 @@ export default routes;
   write() {
     const { outputDir } = this.options;
     const code = this.generateCode();
-    if (!existsSync2(outputDir)) {
-      mkdirSync(outputDir, { recursive: true });
+    if (!existsSync8(outputDir)) {
+      mkdirSync3(outputDir, { recursive: true });
     }
-    writeFileSync(join(outputDir, "routes.tsx"), code, "utf-8");
+    writeFileSync5(join8(outputDir, "routes.tsx"), code, "utf-8");
     if (process.env.DEBUG) console.log(`[ywkf] \u7EA6\u5B9A\u5F0F\u8DEF\u7531\u5DF2\u751F\u6210`);
   }
 };
@@ -872,8 +2989,8 @@ ${startupBody}
 }
 
 // src/generator/templates/env-types.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync2 } from "fs";
+import { join as join9 } from "path";
 function generateEnvTypes(cwd, config) {
   const envVars = collectEnvVars(cwd, config);
   const envInterface = envVars.map((key) => `    readonly ${key}: string;`).join("\n");
@@ -946,19 +3063,19 @@ declare module "*.md" {
 }
 function collectEnvVars(cwd, config) {
   const envVars = /* @__PURE__ */ new Set();
-  const publicEnvPath = join2(cwd, config.env.publicEnvFile || "config/env/.env.public");
-  if (existsSync3(publicEnvPath)) {
-    const content = readFileSync(publicEnvPath, "utf-8");
+  const publicEnvPath = join9(cwd, config.env.publicEnvFile || "config/env/.env.public");
+  if (existsSync9(publicEnvPath)) {
+    const content = readFileSync2(publicEnvPath, "utf-8");
     parseEnvFile(content, envVars);
   }
-  const devEnvPath = join2(cwd, config.env.envDir || "config/env", ".env.development");
-  if (existsSync3(devEnvPath)) {
-    const content = readFileSync(devEnvPath, "utf-8");
+  const devEnvPath = join9(cwd, config.env.envDir || "config/env", ".env.development");
+  if (existsSync9(devEnvPath)) {
+    const content = readFileSync2(devEnvPath, "utf-8");
     parseEnvFile(content, envVars);
   }
-  const prodEnvPath = join2(cwd, config.env.envDir || "config/env", ".env.production");
-  if (existsSync3(prodEnvPath)) {
-    const content = readFileSync(prodEnvPath, "utf-8");
+  const prodEnvPath = join9(cwd, config.env.envDir || "config/env", ".env.production");
+  if (existsSync9(prodEnvPath)) {
+    const content = readFileSync2(prodEnvPath, "utf-8");
     parseEnvFile(content, envVars);
   }
   return Array.from(envVars).sort();
@@ -1000,7 +3117,7 @@ var YwkfGenerator = class {
   constructor(context, pluginHooks = []) {
     this.context = {
       ...context,
-      outputDir: context.outputDir || join3(context.cwd, ".ywkf")
+      outputDir: context.outputDir || join10(context.cwd, ".ywkf")
     };
     this.pluginHooks = pluginHooks;
   }
@@ -1010,7 +3127,7 @@ var YwkfGenerator = class {
   async generate() {
     const { outputDir } = this.context;
     this.ensureDir(outputDir);
-    this.ensureDir(join3(outputDir, "types"));
+    this.ensureDir(join10(outputDir, "types"));
     this.generateConfigSnapshot();
     this.generateRoutes();
     this.generateBootstrapFile();
@@ -1029,7 +3146,7 @@ var YwkfGenerator = class {
    */
   generateConfigSnapshot() {
     const { outputDir, config } = this.context;
-    const configPath = join3(outputDir, "config.json");
+    const configPath = join10(outputDir, "config.json");
     const serializableConfig = JSON.parse(
       JSON.stringify(config, (_key, value) => {
         if (typeof value === "function") {
@@ -1048,7 +3165,7 @@ var YwkfGenerator = class {
     if (!config.router.conventional) {
       return;
     }
-    const pagesDir = join3(cwd, config.router.pagesDir || "src/pages");
+    const pagesDir = join10(cwd, config.router.pagesDir || "src/pages");
     const generator = new ConventionalRouteGenerator({
       pagesDir,
       outputDir,
@@ -1056,7 +3173,7 @@ var YwkfGenerator = class {
       loading: config.router.loading
     });
     const content = generator.generateCode();
-    const routesPath = join3(outputDir, "routes.tsx");
+    const routesPath = join10(outputDir, "routes.tsx");
     this.writeFileIfChanged(routesPath, content);
   }
   /**
@@ -1074,7 +3191,7 @@ var YwkfGenerator = class {
         }
       }
     }
-    const bootstrapPath = join3(outputDir, "bootstrap.tsx");
+    const bootstrapPath = join10(outputDir, "bootstrap.tsx");
     this.writeFileIfChanged(bootstrapPath, content);
   }
   /**
@@ -1092,7 +3209,7 @@ var YwkfGenerator = class {
         }
       }
     }
-    const entryPath = join3(outputDir, "index.tsx");
+    const entryPath = join10(outputDir, "index.tsx");
     this.writeFileIfChanged(entryPath, content);
   }
   /**
@@ -1128,8 +3245,8 @@ var YwkfGenerator = class {
         const files = hooks.generateFiles(this.context);
         if (files) {
           for (const file of files) {
-            const filePath = join3(outputDir, file.path);
-            const dir = join3(filePath, "..");
+            const filePath = join10(outputDir, file.path);
+            const dir = join10(filePath, "..");
             this.ensureDir(dir);
             this.writeFileIfChanged(filePath, file.content);
           }
@@ -1143,18 +3260,18 @@ var YwkfGenerator = class {
   generateTypes() {
     const { outputDir, config, cwd } = this.context;
     const envTypesContent = generateEnvTypes(cwd, config);
-    this.writeFileIfChanged(join3(outputDir, "types", "env.d.ts"), envTypesContent);
+    this.writeFileIfChanged(join10(outputDir, "types", "env.d.ts"), envTypesContent);
     if (config.router.conventional) {
       const routeTypesContent = generateRouteTypes();
-      this.writeFileIfChanged(join3(outputDir, "types", "routes.d.ts"), routeTypesContent);
+      this.writeFileIfChanged(join10(outputDir, "types", "routes.d.ts"), routeTypesContent);
     }
   }
   /**
    * 确保目录存在
    */
   ensureDir(dir) {
-    if (!existsSync4(dir)) {
-      mkdirSync2(dir, { recursive: true });
+    if (!existsSync10(dir)) {
+      mkdirSync4(dir, { recursive: true });
     }
   }
   /**
@@ -1166,14 +3283,14 @@ var YwkfGenerator = class {
     if (lastContent === normalizedContent) {
       return;
     }
-    if (existsSync4(filePath)) {
-      const existingContent = readFileSync2(filePath, "utf-8");
+    if (existsSync10(filePath)) {
+      const existingContent = readFileSync3(filePath, "utf-8");
       if (this.normalizeContent(existingContent) === normalizedContent) {
         this.lastGeneratedContent.set(filePath, normalizedContent);
         return;
       }
     }
-    writeFileSync2(filePath, content, "utf-8");
+    writeFileSync6(filePath, content, "utf-8");
     this.lastGeneratedContent.set(filePath, normalizedContent);
   }
   /**
@@ -1303,8 +3420,8 @@ var YwkfGeneratorPlugin = class {
    */
   watchPages() {
     const { config, cwd } = this.options;
-    const pagesDir = join4(cwd, config.router.pagesDir || "src/pages");
-    if (!existsSync5(pagesDir)) {
+    const pagesDir = join11(cwd, config.router.pagesDir || "src/pages");
+    if (!existsSync11(pagesDir)) {
       return;
     }
     this.isWatching = true;
@@ -1371,7 +3488,7 @@ var YwkfGeneratorPlugin = class {
 // src/rspack/base.ts
 var require2 = createRequire(import.meta.url);
 var __dirname = dirname(fileURLToPath(import.meta.url));
-var coreNodeModules = join5(__dirname, "../../node_modules");
+var coreNodeModules = join12(__dirname, "../../node_modules");
 function createBaseConfig(config, cwd, options = {}) {
   const isDev = options.isDev ?? process.env.NODE_ENV !== "production";
   const { resolveApp } = createPathResolver(cwd);
@@ -1384,16 +3501,16 @@ function createBaseConfig(config, cwd, options = {}) {
     "@locales": resolveApp("locales"),
     "@public": resolveApp("public"),
     // 约定式路由生成的文件
-    "@ywkf/routes": join5(ywkfOutputDir, "routes.tsx"),
+    "@ywkf/routes": join12(ywkfOutputDir, "routes.tsx"),
     // 请求层（由 reactQueryPlugin 生成）
-    "@ywkf/request": join5(ywkfOutputDir, "request.ts"),
+    "@ywkf/request": join12(ywkfOutputDir, "request.ts"),
     // Store 工具（由 zustandPlugin 生成）
-    "@ywkf/store": join5(ywkfOutputDir, "store.ts")
+    "@ywkf/store": join12(ywkfOutputDir, "store.ts")
   };
   const alias = { ...defaultAlias, ...userAlias };
   return {
     // 使用 .ywkf/index.tsx 作为入口（由框架生成）
-    entry: [join5(ywkfOutputDir, "index.tsx")],
+    entry: [join12(ywkfOutputDir, "index.tsx")],
     resolve: {
       extensions: [".ts", ".tsx", ".jsx", ".js", ".json", ".mjs"],
       symlinks: true,
@@ -1493,14 +3610,14 @@ function createBaseConfig(config, cwd, options = {}) {
       ]
     },
     plugins: [
-      new rspack.ProvidePlugin({
+      new rspack2.ProvidePlugin({
         process: "process/browser.js",
         Buffer: ["buffer", "Buffer"]
       }),
-      new rspack.DefinePlugin({
+      new rspack2.DefinePlugin({
         "process.env": JSON.stringify(process.env)
       }),
-      new rspack.HtmlRspackPlugin({
+      new rspack2.HtmlRspackPlugin({
         template: resolveApp(html.template ?? "public/index.html"),
         filename: "index.html",
         inject: "body",
@@ -1512,7 +3629,7 @@ function createBaseConfig(config, cwd, options = {}) {
           mountRoot: html.mountRoot ?? appName
         }
       }),
-      new rspack.CopyRspackPlugin({
+      new rspack2.CopyRspackPlugin({
         patterns: [
           {
             from: resolveApp("public/images"),
@@ -1775,7 +3892,7 @@ function createDevConfig(config, cwd) {
 }
 
 // src/rspack/prod.ts
-import { rspack as rspack2 } from "@rspack/core";
+import { rspack as rspack3 } from "@rspack/core";
 import { merge as merge2 } from "webpack-merge";
 function createProdConfig(config, cwd) {
   const baseConfig = createBaseConfig(config, cwd, { isDev: false });
@@ -1788,7 +3905,7 @@ function createProdConfig(config, cwd) {
         test: /\.less$/,
         include: [/[\\/]node_modules[\\/].*antd/, /[\\/]node_modules[\\/]@4399ywkf[\\/]design/],
         use: [
-          { loader: rspack2.CssExtractRspackPlugin.loader },
+          { loader: rspack3.CssExtractRspackPlugin.loader },
           {
             loader: "css-loader",
             options: { sourceMap: true }
@@ -1816,7 +3933,7 @@ function createProdConfig(config, cwd) {
             {
               test: /\.module\.less$/,
               use: [
-                { loader: rspack2.CssExtractRspackPlugin.loader },
+                { loader: rspack3.CssExtractRspackPlugin.loader },
                 {
                   loader: "css-loader",
                   options: {
@@ -1841,7 +3958,7 @@ function createProdConfig(config, cwd) {
             },
             {
               use: [
-                { loader: rspack2.CssExtractRspackPlugin.loader },
+                { loader: rspack3.CssExtractRspackPlugin.loader },
                 {
                   loader: "css-loader",
                   options: { sourceMap: true }
@@ -1871,7 +3988,7 @@ function createProdConfig(config, cwd) {
             {
               test: /\.module\.s[ac]ss$/,
               use: [
-                { loader: rspack2.CssExtractRspackPlugin.loader },
+                { loader: rspack3.CssExtractRspackPlugin.loader },
                 {
                   loader: "css-loader",
                   options: {
@@ -1896,7 +4013,7 @@ function createProdConfig(config, cwd) {
             },
             {
               use: [
-                { loader: rspack2.CssExtractRspackPlugin.loader },
+                { loader: rspack3.CssExtractRspackPlugin.loader },
                 {
                   loader: "css-loader",
                   options: { sourceMap: true }
@@ -1922,7 +4039,7 @@ function createProdConfig(config, cwd) {
           test: /\.css$/,
           include: [resolveApp("src/index.css")],
           use: [
-            { loader: rspack2.CssExtractRspackPlugin.loader },
+            { loader: rspack3.CssExtractRspackPlugin.loader },
             "css-loader",
             {
               loader: "postcss-loader",
@@ -1941,7 +4058,7 @@ function createProdConfig(config, cwd) {
         include: [resolveApp("src")],
         exclude: style.tailwindcss ? [resolveApp("src/index.css")] : [],
         use: [
-          { loader: rspack2.CssExtractRspackPlugin.loader },
+          { loader: rspack3.CssExtractRspackPlugin.loader },
           {
             loader: "css-loader",
             options: { sourceMap: true }
@@ -1972,7 +4089,7 @@ function createProdConfig(config, cwd) {
     },
     module: styleRules,
     plugins: [
-      new rspack2.CssExtractRspackPlugin({
+      new rspack3.CssExtractRspackPlugin({
         filename: "[name].[contenthash:8].css",
         chunkFilename: "[name].[contenthash:8].chunk.css"
       })
@@ -1980,7 +4097,7 @@ function createProdConfig(config, cwd) {
     optimization: {
       minimize: true,
       minimizer: [
-        new rspack2.SwcJsMinimizerRspackPlugin({
+        new rspack3.SwcJsMinimizerRspackPlugin({
           exclude: [resolveApp("node_modules")],
           minimizerOptions: {
             compress: {
@@ -1990,7 +4107,7 @@ function createProdConfig(config, cwd) {
             }
           }
         }),
-        new rspack2.LightningCssMinimizerRspackPlugin()
+        new rspack3.LightningCssMinimizerRspackPlugin()
       ]
     }
   };
@@ -2017,27 +4134,27 @@ function createRspackConfig(config, cwd, options = {}) {
 }
 
 // src/cli/env.ts
-import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve2 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve3 } from "path";
 import dotenv from "dotenv";
 function preloadEnv(cwd, mode, nodeEnv) {
   process.env.NODE_ENV = nodeEnv;
   process.env.APP_MODE = mode;
   const defaultPaths = [
-    resolve2(cwd, "config/env/.env.public"),
-    resolve2(cwd, ".env.public"),
-    resolve2(cwd, ".env")
+    resolve3(cwd, "config/env/.env.public"),
+    resolve3(cwd, ".env.public"),
+    resolve3(cwd, ".env")
   ];
   for (const envPath of defaultPaths) {
-    if (existsSync6(envPath)) {
+    if (existsSync12(envPath)) {
       dotenv.config({ path: envPath });
       break;
     }
   }
-  const modeEnvPaths = [resolve2(cwd, `config/env/.env.${mode}`), resolve2(cwd, `.env.${mode}`)];
+  const modeEnvPaths = [resolve3(cwd, `config/env/.env.${mode}`), resolve3(cwd, `.env.${mode}`)];
   for (const envPath of modeEnvPaths) {
-    if (existsSync6(envPath)) {
-      const envContent = readFileSync3(envPath, "utf-8");
+    if (existsSync12(envPath)) {
+      const envContent = readFileSync4(envPath, "utf-8");
       const parsed = dotenv.parse(envContent);
       for (const key in parsed) {
         process.env[key] = parsed[key];
@@ -2050,13 +4167,13 @@ function preloadEnv(cwd, mode, nodeEnv) {
 }
 function loadEnv(config, cwd, mode, nodeEnv) {
   const { env } = config;
-  const publicEnvPath = resolve2(cwd, env.publicEnvFile ?? "config/env/.env.public");
-  if (existsSync6(publicEnvPath)) {
+  const publicEnvPath = resolve3(cwd, env.publicEnvFile ?? "config/env/.env.public");
+  if (existsSync12(publicEnvPath)) {
     dotenv.config({ path: publicEnvPath });
   }
-  const modeEnvPath = resolve2(cwd, env.envDir ?? "config/env", `.env.${mode}`);
-  if (existsSync6(modeEnvPath)) {
-    const envContent = readFileSync3(modeEnvPath, "utf-8");
+  const modeEnvPath = resolve3(cwd, env.envDir ?? "config/env", `.env.${mode}`);
+  if (existsSync12(modeEnvPath)) {
+    const envContent = readFileSync4(modeEnvPath, "utf-8");
     const parsed = dotenv.parse(envContent);
     for (const key in parsed) {
       process.env[key] = parsed[key];
@@ -2075,7 +4192,7 @@ function loadEnv(config, cwd, mode, nodeEnv) {
 // src/cli/printer.ts
 import { createRequire as createRequire3 } from "module";
 import os from "os";
-import { dirname as dirname2, join as join6 } from "path";
+import { dirname as dirname2, join as join13 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import chalk from "chalk";
 var __filename = fileURLToPath2(import.meta.url);
@@ -2085,7 +4202,7 @@ var _version = null;
 function getFrameworkVersion() {
   if (_version) return _version;
   try {
-    const pkgPath = join6(__dirname2, "../../package.json");
+    const pkgPath = join13(__dirname2, "../../package.json");
     const pkg = require3(pkgPath);
     _version = pkg.version || "0.0.0";
   } catch {
@@ -2328,11 +4445,11 @@ async function build(options = {}) {
     printer.printBuildStart();
     printer.updateProgress(0, "preparing");
     rspackConfig.plugins = rspackConfig.plugins || [];
-    rspackConfig.plugins.push(new rspack3.ProgressPlugin(createProgressHandler(printer)));
+    rspackConfig.plugins.push(new rspack4.ProgressPlugin(createProgressHandler(printer)));
     rspackConfig.stats = "none";
     rspackConfig.infrastructureLogging = { level: "none" };
-    const compiler = rspack3(rspackConfig);
-    const stats = await new Promise((resolve3, reject) => {
+    const compiler = rspack4(rspackConfig);
+    const stats = await new Promise((resolve4, reject) => {
       compiler.run((err, stats2) => {
         if (err) {
           reject(err);
@@ -2342,13 +4459,13 @@ async function build(options = {}) {
           reject(new Error("Build failed: no stats available"));
           return;
         }
-        resolve3(stats2);
+        resolve4(stats2);
       });
     });
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       compiler.close((err) => {
         if (err) reject(err);
-        else resolve3();
+        else resolve4();
       });
     });
     const hasErrors = stats.hasErrors();
@@ -2372,24 +4489,24 @@ async function build(options = {}) {
 }
 
 // src/cli/dev.ts
-import { rspack as rspack4 } from "@rspack/core";
+import { rspack as rspack5 } from "@rspack/core";
 import { RspackDevServer } from "@rspack/dev-server";
 import chalk3 from "chalk";
 
 // src/cli/port.ts
 import net from "net";
 function isPortAvailable(port, host) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const server = net.createServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve3(false);
+        resolve4(false);
       } else {
-        resolve3(false);
+        resolve4(false);
       }
     });
     server.once("listening", () => {
-      server.close(() => resolve3(true));
+      server.close(() => resolve4(true));
     });
     server.listen(port, host);
   });
@@ -2434,7 +4551,7 @@ async function dev(options = {}) {
     printer.printBuildStart();
     printer.updateProgress(0, "preparing");
     rspackConfig.plugins = rspackConfig.plugins || [];
-    rspackConfig.plugins.push(new rspack4.ProgressPlugin(createProgressHandler(printer)));
+    rspackConfig.plugins.push(new rspack5.ProgressPlugin(createProgressHandler(printer)));
     rspackConfig.stats = "none";
     rspackConfig.infrastructureLogging = { level: "none" };
     if (rspackConfig.devServer) {
@@ -2447,7 +4564,7 @@ async function dev(options = {}) {
         progress: false
       };
     }
-    const compiler = rspack4(rspackConfig);
+    const compiler = rspack5(rspackConfig);
     compiler.hooks.done.tap("ywkf-dev-printer", (stats) => {
       const hasErrors = stats.hasErrors();
       if (hasErrors) {
@@ -2502,7 +4619,7 @@ var __dirname3 = dirname3(__filename2);
 var require4 = createRequire4(import.meta.url);
 var version = "0.0.0";
 try {
-  const pkg = require4(join7(__dirname3, "../../package.json"));
+  const pkg = require4(join14(__dirname3, "../../package.json"));
   version = pkg.version;
 } catch {
 }