@4399ywkf/core 4.0.85 → 5.0.0

package/dist/index.js

@@ -1,51 +1,3673 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  Env: () => import_types.Env,
-  Generator: () => import_generator.Generator,
-  GeneratorType: () => import_generator.GeneratorType,
-  IAdd: () => import_types.IAdd,
-  IEvent: () => import_types.IEvent,
-  IModify: () => import_types.IModify,
-  IRoute: () => import_types.IRoute
+// src/config/schema.ts
+function defineConfig(config) {
+  return config;
+}
+var defaultConfig = {
+  appName: "app",
+  appCName: "\u5E94\u7528",
+  dev: {
+    port: 3e3,
+    host: "localhost",
+    proxy: {},
+    https: false
+  },
+  output: {
+    path: "dist",
+    publicPath: "/",
+    clean: true
+  },
+  html: {
+    title: "\u5E94\u7528",
+    template: "public/index.html",
+    favicon: "public/favicon.ico",
+    mountRoot: "root"
+  },
+  style: {
+    cssModules: true,
+    less: { enabled: true, lessOptions: { javascriptEnabled: true } },
+    sass: { enabled: true, sassOptions: {} },
+    tailwindcss: true
+  },
+  router: {
+    basename: "/",
+    conventional: false,
+    pagesDir: "src/pages",
+    exclude: [
+      /\/components?\//,
+      /\/models\//,
+      /\/utils?\//,
+      /^_/,
+      /\.d\.ts$/,
+      /\.(test|spec|e2e)\.(ts|tsx|js|jsx)$/
+    ]
+  },
+  microFrontend: {
+    enabled: false,
+    name: "app",
+    framework: "qiankun"
+  },
+  performance: {
+    rsdoctor: false,
+    splitChunks: true,
+    dropConsole: false
+  },
+  tools: {},
+  env: {
+    publicEnvFile: "config/env/.env.public",
+    envDir: "config/env"
+  },
+  alias: {},
+  plugins: []
+};
+
+// src/config/loader.ts
+import { existsSync } from "fs";
+import { resolve, extname } from "path";
+import { pathToFileURL } from "url";
+import deepmerge from "deepmerge";
+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)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+async function loadTsConfig(configPath) {
+  const jiti = (await import("jiti")).default;
+  const loader = jiti(configPath, {
+    interopDefault: true
+  });
+  const config = loader(configPath);
+  return config.default || config;
+}
+async function loadJsConfig(configPath) {
+  const fileUrl = pathToFileURL(configPath).href;
+  const module = await import(fileUrl);
+  return module.default || module;
+}
+async function loadConfigFile(configPath) {
+  const ext = extname(configPath);
+  if (ext === ".ts" || ext === ".mts") {
+    return loadTsConfig(configPath);
+  }
+  return loadJsConfig(configPath);
+}
+function mergeConfig(userConfig, baseConfig = defaultConfig) {
+  return deepmerge(baseConfig, userConfig, {
+    arrayMerge: (_, sourceArray) => sourceArray
+  });
+}
+async function resolveConfig(cwd) {
+  const configPath = findConfigFile(cwd);
+  if (!configPath) {
+    console.warn(
+      "\u26A0\uFE0F  \u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6 (ywkf.config.ts)\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E"
+    );
+    return {
+      config: defaultConfig,
+      configPath: null
+    };
+  }
+  try {
+    const userConfig = await loadConfigFile(configPath);
+    const config = mergeConfig(userConfig);
+    return { config, configPath };
+  } catch (error) {
+    console.error("\u274C \u914D\u7F6E\u6587\u4EF6\u52A0\u8F7D\u5931\u8D25:", error);
+    throw error;
+  }
+}
+function createPathResolver(cwd) {
+  return {
+    resolveApp: (relativePath) => resolve(cwd, relativePath),
+    cwd
+  };
+}
+
+// src/rspack/index.ts
+import { RsdoctorRspackPlugin } from "@rsdoctor/rspack-plugin";
+
+// src/rspack/dev.ts
+import { merge } from "webpack-merge";
+import { createRequire as createRequire2 } from "module";
+
+// src/rspack/base.ts
+import { rspack } from "@rspack/core";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join as join5 } from "path";
+
+// src/generator/plugin.ts
+import { watch, existsSync as existsSync5 } from "fs";
+import { join as join4 } from "path";
+
+// src/generator/generator.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/router/generator.ts
+import { existsSync as existsSync2, readdirSync, statSync, mkdirSync, writeFileSync } from "fs";
+import { join, relative } from "path";
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  "components",
+  "hooks",
+  "utils",
+  "services",
+  "models",
+  "assets",
+  "types",
+  "constants",
+  "styles"
+]);
+var CONVENTION_FILES = {
+  page: /^page\.(tsx?|jsx?)$/,
+  layout: /^layout\.(tsx?|jsx?)$/,
+  error: /^error\.(tsx?|jsx?)$/,
+  loading: /^loading\.(tsx?|jsx?)$/,
+  catchAll: /^\$\.(tsx?|jsx?)$/
+};
+var ConventionalRouteGenerator = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  generate() {
+    const { pagesDir } = this.options;
+    if (!existsSync2(pagesDir)) {
+      console.warn(`[ywkf] \u9875\u9762\u76EE\u5F55\u4E0D\u5B58\u5728: ${pagesDir}`);
+      return [];
+    }
+    return this.scanDirectory(pagesDir, "/");
+  }
+  /**
+   * 扫描目录，生成路由树
+   */
+  scanDirectory(dir, routePath) {
+    const entries = readdirSync(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));
+    const loadingFile = entries.find((e) => CONVENTION_FILES.loading.test(e));
+    const catchAllFile = entries.find((e) => CONVENTION_FILES.catchAll.test(e));
+    const subDirs = entries.filter((e) => {
+      if (e.startsWith(".")) return false;
+      if (EXCLUDED_DIRS.has(e)) return false;
+      return statSync(join(dir, e)).isDirectory();
+    });
+    const childRoutes = [];
+    for (const subDir of subDirs) {
+      const subDirPath = join(dir, subDir);
+      if (subDir.startsWith("__")) {
+        const pathlessRoutes = this.scanDirectory(subDirPath, routePath);
+        const pathlessLayout = readdirSync(subDirPath).find(
+          (e) => CONVENTION_FILES.layout.test(e)
+        );
+        if (pathlessLayout) {
+          const pathlessChildren = this.scanDirectory(subDirPath, routePath);
+          childRoutes.push({
+            path: routePath,
+            name: this.generateRouteName(subDir.slice(2)),
+            layoutFile: relative(this.options.pagesDir, join(subDirPath, pathlessLayout)),
+            isLayout: true,
+            pathless: true,
+            children: pathlessChildren.filter(
+              (r) => r.layoutFile !== relative(this.options.pagesDir, join(subDirPath, pathlessLayout))
+            )
+          });
+        } else {
+          childRoutes.push(...pathlessRoutes);
+        }
+        continue;
+      }
+      const subRoutePath = this.resolveRoutePath(subDir, routePath);
+      childRoutes.push(...this.scanDirectory(subDirPath, subRoutePath));
+    }
+    const routeName = this.generateRouteName(routePath);
+    const relPath = (file) => relative(this.options.pagesDir, join(dir, file));
+    if (layoutFile) {
+      const layoutChildren = [];
+      if (pageFile) {
+        layoutChildren.push({
+          path: routePath,
+          file: relPath(pageFile),
+          name: routeName + "Index",
+          index: true
+        });
+      }
+      if (catchAllFile) {
+        layoutChildren.push({
+          path: "*",
+          file: relPath(catchAllFile),
+          name: routeName + "CatchAll"
+        });
+      }
+      layoutChildren.push(...childRoutes);
+      return [
+        {
+          path: routePath,
+          layoutFile: relPath(layoutFile),
+          errorFile: errorFile ? relPath(errorFile) : void 0,
+          loadingFile: loadingFile ? relPath(loadingFile) : void 0,
+          name: routeName,
+          isLayout: true,
+          children: layoutChildren
+        }
+      ];
+    }
+    const result = [];
+    if (pageFile) {
+      result.push({
+        path: routePath,
+        file: relPath(pageFile),
+        errorFile: errorFile ? relPath(errorFile) : void 0,
+        name: routeName
+      });
+    }
+    if (catchAllFile) {
+      result.push({
+        path: "*",
+        file: relPath(catchAllFile),
+        name: routeName + "CatchAll"
+      });
+    }
+    result.push(...childRoutes);
+    return result;
+  }
+  /**
+   * 解析目录名到路由路径
+   *
+   * - [id]       → :id
+   * - [id$]      → :id?
+   * - [...slug]  → *
+   * - user.profile → user/profile
+   */
+  resolveRoutePath(dirName, parentPath) {
+    let segment;
+    if (dirName.match(/^\[\.\.\.(.+)\]$/)) {
+      segment = "*";
+    } else if (dirName.match(/^\[(.+)\$\]$/)) {
+      const param = dirName.slice(1, -2);
+      segment = `:${param}?`;
+    } else if (dirName.match(/^\[(.+)\]$/)) {
+      const param = dirName.slice(1, -1);
+      segment = `:${param}`;
+    } else if (dirName.includes(".")) {
+      segment = dirName.replace(/\./g, "/");
+    } else {
+      segment = dirName;
+    }
+    return parentPath === "/" ? `/${segment}` : `${parentPath}/${segment}`;
+  }
+  /**
+   * 生成有效的 JS 标识符名称
+   */
+  generateRouteName(path) {
+    const name = path.split("/").filter(Boolean).map(
+      (s) => s.replace(/^:/, "Param").replace(/\?$/, "Optional").replace(/^\*$/, "CatchAll")
+    ).map((s) => {
+      const cleaned = s.replace(/[^a-zA-Z0-9]/g, "");
+      if (!cleaned) return "";
+      return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+    }).join("");
+    if (!name || /^\d/.test(name)) {
+      return "Page" + (name || "Root");
+    }
+    return name;
+  }
+  // ===== 代码生成 =====
+  generateCode() {
+    const routes = this.generate();
+    const lazyImports = [];
+    const errorImports = [];
+    const loadingImports = [];
+    this.collectImports(routes, lazyImports, errorImports, loadingImports);
+    return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/core \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u4FEE\u6539
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+import React, { lazy, Suspense } from "react";
+import { createBrowserRouter, type RouteObject } from "react-router";
+
+// \u61D2\u52A0\u8F7D\u9875\u9762\u7EC4\u4EF6
+${lazyImports.join("\n")}
+${errorImports.length > 0 ? "\n// \u9519\u8BEF\u8FB9\u754C\u7EC4\u4EF6\n" + errorImports.join("\n") : ""}
+${loadingImports.length > 0 ? "\n// \u52A0\u8F7D\u72B6\u6001\u7EC4\u4EF6\n" + loadingImports.join("\n") : ""}
+
+// \u9ED8\u8BA4\u52A0\u8F7D\u72B6\u6001
+const DefaultLoading = () => <div style={{ padding: 24, textAlign: "center" }}>\u52A0\u8F7D\u4E2D...</div>;
+
+// \u61D2\u52A0\u8F7D\u5305\u88C5
+function LazyRoute({
+  Component,
+  Loading = DefaultLoading,
+}: {
+  Component: React.LazyExoticComponent<React.ComponentType<unknown>>;
+  Loading?: React.ComponentType;
+}) {
+  return (
+    <Suspense fallback={<Loading />}>
+      <Component />
+    </Suspense>
+  );
+}
+
+// \u8DEF\u7531\u914D\u7F6E
+export const routes: RouteObject[] = ${this.emitRouteArray(routes)};
+
+/**
+ * \u521B\u5EFA\u8DEF\u7531\u5B9E\u4F8B
+ */
+export function createRouter(basename?: string) {
+  return createBrowserRouter(routes, { basename: basename || "/" });
+}
+
+export default routes;
+`;
+  }
+  collectImports(routes, lazyImports, errorImports, loadingImports) {
+    for (const route of routes) {
+      const name = route.name;
+      const toImportPath = (f) => f.replace(/\.(tsx?|jsx?)$/, "");
+      if (route.isLayout && route.layoutFile) {
+        lazyImports.push(
+          `const ${name}Layout = lazy(() => import("@/pages/${toImportPath(route.layoutFile)}"));`
+        );
+      }
+      if (route.file) {
+        lazyImports.push(
+          `const ${name}Page = lazy(() => import("@/pages/${toImportPath(route.file)}"));`
+        );
+      }
+      if (route.errorFile) {
+        errorImports.push(
+          `const ${name}Error = lazy(() => import("@/pages/${toImportPath(route.errorFile)}"));`
+        );
+      }
+      if (route.loadingFile) {
+        loadingImports.push(
+          `const ${name}Loading = lazy(() => import("@/pages/${toImportPath(route.loadingFile)}"));`
+        );
+      }
+      if (route.children) {
+        this.collectImports(route.children, lazyImports, errorImports, loadingImports);
+      }
+    }
+  }
+  emitRouteArray(routes, parentPath) {
+    const items = routes.map((r) => this.emitRouteObject(r, parentPath));
+    return `[
+  ${items.join(",\n  ")}
+]`;
+  }
+  emitRouteObject(route, parentPath) {
+    const parts = [];
+    const name = route.name;
+    if (route.index) {
+      parts.push("index: true");
+    } else if (route.pathless) {
+    } else if (route.path === "*") {
+      parts.push(`path: "*"`);
+    } else if (parentPath && route.path.startsWith(parentPath) && parentPath !== "/") {
+      const rel = route.path.slice(parentPath.length + 1);
+      parts.push(`path: "${rel || ""}"`);
+    } else {
+      parts.push(`path: "${route.path}"`);
+    }
+    if (route.isLayout && route.layoutFile) {
+      const loadingProp = route.loadingFile ? ` Loading={${name}Loading}` : "";
+      parts.push(`element: <LazyRoute Component={${name}Layout}${loadingProp} />`);
+    } else if (route.file) {
+      parts.push(`element: <LazyRoute Component={${name}Page} />`);
+    }
+    if (route.errorFile) {
+      parts.push(`errorElement: <LazyRoute Component={${name}Error} />`);
+    }
+    if (route.children && route.children.length > 0) {
+      const childParent = route.pathless ? parentPath : route.path;
+      parts.push(`children: ${this.emitRouteArray(route.children, childParent)}`);
+    }
+    return `{
+    ${parts.join(",\n    ")}
+  }`;
+  }
+  /**
+   * 写入路由文件
+   */
+  write() {
+    const { outputDir } = this.options;
+    const code = this.generateCode();
+    if (!existsSync2(outputDir)) {
+      mkdirSync(outputDir, { recursive: true });
+    }
+    writeFileSync(join(outputDir, "routes.tsx"), code, "utf-8");
+    console.log(`[ywkf] \u7EA6\u5B9A\u5F0F\u8DEF\u7531\u5DF2\u751F\u6210`);
+  }
+};
+function generateConventionalRoutes(options) {
+  new ConventionalRouteGenerator(options).write();
+}
+
+// src/generator/templates/entry.ts
+function generateEntry(config, injections = {}) {
+  const imports = [
+    `import "@/index.css";`,
+    `import { runApp } from "./bootstrap";`,
+    ...injections.imports || []
+  ];
+  const topLevel = injections.topLevel || [];
+  const exports = injections.exports || [];
+  const hasPluginExports = exports.length > 0;
+  const startupCode = hasPluginExports ? `// \u72EC\u7ACB\u8FD0\u884C\u6A21\u5F0F
+if (shouldRunIndependently !== false) {
+  runApp();
+}` : `// \u542F\u52A8\u5E94\u7528
+runApp();`;
+  return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/core \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u4FEE\u6539
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+${imports.join("\n")}
+
+${topLevel.length > 0 ? topLevel.join("\n") + "\n" : ""}${exports.length > 0 ? exports.join("\n") + "\n\n" : ""}${startupCode}
+`;
+}
+
+// src/generator/templates/bootstrap.ts
+function generateBootstrap(config, injections = {}) {
+  const { appName, router } = config;
+  const routerImport = router.conventional ? `import { createRouter } from "./routes";` : `import { createRouter } from "@/routes";`;
+  const imports = [
+    `import { bootstrap, type AppConfig } from "@4399ywkf/core/runtime";`,
+    routerImport,
+    ...injections.imports || []
+  ];
+  const topLevel = injections.topLevel || [];
+  const exports = injections.exports || [];
+  return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/core \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u4FEE\u6539
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+${imports.join("\n")}
+
+/**
+ * \u5E94\u7528\u540D\u79F0
+ */
+export const APP_NAME = "${appName}";
+
+/**
+ * \u8DEF\u7531 basename
+ */
+export const BASENAME = "${router.basename || "/"}";
+
+/**
+ * \u83B7\u53D6\u7528\u6237\u81EA\u5B9A\u4E49\u914D\u7F6E\uFF08\u5982\u679C\u5B58\u5728\uFF09
+ * \u7528\u6237\u53EF\u5728 src/app.config.ts \u4E2D\u5BFC\u51FA\u914D\u7F6E\u6765\u8986\u76D6\u9ED8\u8BA4\u503C
+ */
+async function getUserConfig(): Promise<Partial<AppConfig>> {
+  try {
+    // webpackIgnore \u6CE8\u91CA\u8BA9\u6253\u5305\u5668\u8DF3\u8FC7\u6A21\u5757\u5B58\u5728\u6027\u68C0\u67E5
+    const userConfigModule = await import(/* webpackIgnore: true */ "@/app.config");
+    return userConfigModule.default || {};
+  } catch {
+    // \u6587\u4EF6\u4E0D\u5B58\u5728\u65F6\u8FD4\u56DE\u7A7A\u914D\u7F6E
+    return {};
+  }
+}
+
+/**
+ * \u521B\u5EFA\u5E94\u7528\u914D\u7F6E
+ */
+export function createAppConfig(userConfig: Partial<AppConfig> = {}): AppConfig {
+  const router = createRouter(BASENAME);
+
+  const defaultConfig: AppConfig = {
+    appName: APP_NAME,
+    router,
+    basename: BASENAME,
+    rootId: APP_NAME,
+    strictMode: true,
+    antd: {
+      enabled: true,
+    },
+    providers: [],
+    lifecycle: {
+      onMounted() {
+        console.log(\`[\${APP_NAME}] \u5E94\u7528\u5DF2\u6302\u8F7D\`);
+      },
+      onUnmount() {
+        console.log(\`[\${APP_NAME}] \u5E94\u7528\u5DF2\u5378\u8F7D\`);
+      },
+      onError(error) {
+        console.error(\`[\${APP_NAME}] \u5168\u5C40\u9519\u8BEF:\`, error);
+      },
+    },
+  };
+
+  // \u6DF1\u5EA6\u5408\u5E76\u7528\u6237\u914D\u7F6E
+  return {
+    ...defaultConfig,
+    ...userConfig,
+    antd: { ...defaultConfig.antd, ...userConfig.antd },
+    providers: [...(defaultConfig.providers || []), ...(userConfig.providers || [])],
+    lifecycle: { ...defaultConfig.lifecycle, ...userConfig.lifecycle },
+  };
+}
+
+/**
+ * \u542F\u52A8\u5E94\u7528
+ */
+export async function runApp(): Promise<void> {
+  const userConfig = await getUserConfig();
+  await bootstrap(createAppConfig(userConfig));
+}
+${topLevel.length > 0 ? "\n" + topLevel.join("\n") : ""}
+${exports.length > 0 ? "\n" + exports.join("\n") : ""}
+`;
+}
+
+// src/generator/templates/env-types.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { join as join2 } from "path";
+function generateEnvTypes(cwd, config) {
+  const envVars = collectEnvVars(cwd, config);
+  const envInterface = envVars.map((key) => `    readonly ${key}: string;`).join("\n");
+  return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/core \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u4FEE\u6539
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+/// <reference types="react" />
+/// <reference types="react-dom" />
+
+declare namespace NodeJS {
+  interface ProcessEnv {
+${envInterface}
+    readonly NODE_ENV: "development" | "production" | "test";
+  }
+}
+
+declare module "*.svg" {
+  import * as React from "react";
+  const ReactComponent: React.FunctionComponent<
+    React.SVGProps<SVGSVGElement> & { title?: string }
+  >;
+  export default ReactComponent;
+}
+
+declare module "*.png" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.jpg" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.jpeg" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.gif" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.webp" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.css" {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module "*.less" {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module "*.scss" {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module "*.md" {
+  const content: string;
+  export default content;
+}
+`;
+}
+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");
+    parseEnvFile(content, envVars);
+  }
+  const devEnvPath = join2(cwd, config.env.envDir || "config/env", ".env.development");
+  if (existsSync3(devEnvPath)) {
+    const content = readFileSync(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");
+    parseEnvFile(content, envVars);
+  }
+  return Array.from(envVars).sort();
+}
+function parseEnvFile(content, envVars) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const match = trimmed.match(/^([A-Z_][A-Z0-9_]*)\s*=/);
+    if (match) {
+      envVars.add(match[1]);
+    }
+  }
+}
+
+// src/generator/templates/route-types.ts
+function generateRouteTypes() {
+  return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/core \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u4FEE\u6539
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+import type { RouteObject } from "react-router";
+
+declare module "@ywkf/routes" {
+  export const routes: RouteObject[];
+  export function createRouter(basename?: string): ReturnType<typeof import("react-router").createBrowserRouter>;
+  export default routes;
+}
+`;
+}
+
+// src/generator/generator.ts
+var YwkfGenerator = class {
+  context;
+  pluginHooks;
+  lastGeneratedContent = /* @__PURE__ */ new Map();
+  constructor(context, pluginHooks = []) {
+    this.context = {
+      ...context,
+      outputDir: context.outputDir || join3(context.cwd, ".ywkf")
+    };
+    this.pluginHooks = pluginHooks;
+  }
+  /**
+   * 生成所有文件
+   */
+  async generate() {
+    const { outputDir } = this.context;
+    this.ensureDir(outputDir);
+    this.ensureDir(join3(outputDir, "types"));
+    this.generateConfigSnapshot();
+    this.generateRoutes();
+    this.generateBootstrapFile();
+    this.generateEntryFile();
+    this.generateTypes();
+    await this.generatePluginFiles();
+    for (const hooks of this.pluginHooks) {
+      if (hooks.afterGenerate) {
+        await hooks.afterGenerate(this.context);
+      }
+    }
+    console.log(`[ywkf] \u5DF2\u751F\u6210 .ywkf \u76EE\u5F55`);
+  }
+  /**
+   * 生成配置快照
+   */
+  generateConfigSnapshot() {
+    const { outputDir, config } = this.context;
+    const configPath = join3(outputDir, "config.json");
+    const serializableConfig = JSON.parse(
+      JSON.stringify(config, (key, value) => {
+        if (typeof value === "function") {
+          return "[Function]";
+        }
+        return value;
+      })
+    );
+    this.writeFileIfChanged(
+      configPath,
+      JSON.stringify(serializableConfig, null, 2)
+    );
+  }
+  /**
+   * 生成约定式路由
+   */
+  generateRoutes() {
+    const { cwd, outputDir, config } = this.context;
+    if (!config.router.conventional) {
+      return;
+    }
+    const pagesDir = join3(cwd, config.router.pagesDir || "src/pages");
+    const generator = new ConventionalRouteGenerator({
+      pagesDir,
+      outputDir,
+      basename: config.router.basename
+    });
+    const content = generator.generateCode();
+    const routesPath = join3(outputDir, "routes.tsx");
+    this.writeFileIfChanged(routesPath, content);
+  }
+  /**
+   * 生成启动文件
+   */
+  generateBootstrapFile() {
+    const { outputDir, config } = this.context;
+    const injections = this.collectInjections("bootstrap");
+    let content = generateBootstrap(config, injections);
+    for (const hooks of this.pluginHooks) {
+      if (hooks.modifyBootstrapCode) {
+        const result = hooks.modifyBootstrapCode(content, this.context);
+        if (result) {
+          content = result;
+        }
+      }
+    }
+    const bootstrapPath = join3(outputDir, "bootstrap.tsx");
+    this.writeFileIfChanged(bootstrapPath, content);
+  }
+  /**
+   * 生成入口文件
+   */
+  generateEntryFile() {
+    const { outputDir, config } = this.context;
+    const injections = this.collectInjections("entry");
+    let content = generateEntry(config, injections);
+    for (const hooks of this.pluginHooks) {
+      if (hooks.modifyEntryCode) {
+        const result = hooks.modifyEntryCode(content, this.context);
+        if (result) {
+          content = result;
+        }
+      }
+    }
+    const entryPath = join3(outputDir, "index.tsx");
+    this.writeFileIfChanged(entryPath, content);
+  }
+  /**
+   * 收集插件代码注入
+   */
+  collectInjections(type) {
+    const result = {
+      imports: [],
+      topLevel: [],
+      exports: []
+    };
+    const hookName = type === "entry" ? "injectEntry" : "injectBootstrap";
+    for (const hooks of this.pluginHooks) {
+      const hook = hooks[hookName];
+      if (hook) {
+        const injection = hook(this.context);
+        if (injection) {
+          result.imports?.push(...injection.imports || []);
+          result.topLevel?.push(...injection.topLevel || []);
+          result.exports?.push(...injection.exports || []);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * 生成插件附加文件
+   */
+  async generatePluginFiles() {
+    const { outputDir } = this.context;
+    for (const hooks of this.pluginHooks) {
+      if (hooks.generateFiles) {
+        const files = hooks.generateFiles(this.context);
+        if (files) {
+          for (const file of files) {
+            const filePath = join3(outputDir, file.path);
+            const dir = join3(filePath, "..");
+            this.ensureDir(dir);
+            this.writeFileIfChanged(filePath, file.content);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * 生成类型定义
+   */
+  generateTypes() {
+    const { outputDir, config, cwd } = this.context;
+    const envTypesContent = generateEnvTypes(cwd, config);
+    this.writeFileIfChanged(
+      join3(outputDir, "types", "env.d.ts"),
+      envTypesContent
+    );
+    if (config.router.conventional) {
+      const routeTypesContent = generateRouteTypes();
+      this.writeFileIfChanged(
+        join3(outputDir, "types", "routes.d.ts"),
+        routeTypesContent
+      );
+    }
+  }
+  /**
+   * 确保目录存在
+   */
+  ensureDir(dir) {
+    if (!existsSync4(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+  }
+  /**
+   * 只在内容变化时写入文件（避免触发不必要的热更新）
+   */
+  writeFileIfChanged(filePath, content) {
+    const normalizedContent = this.normalizeContent(content);
+    const lastContent = this.lastGeneratedContent.get(filePath);
+    if (lastContent === normalizedContent) {
+      return;
+    }
+    if (existsSync4(filePath)) {
+      const existingContent = readFileSync2(filePath, "utf-8");
+      if (this.normalizeContent(existingContent) === normalizedContent) {
+        this.lastGeneratedContent.set(filePath, normalizedContent);
+        return;
+      }
+    }
+    writeFileSync2(filePath, content, "utf-8");
+    this.lastGeneratedContent.set(filePath, normalizedContent);
+  }
+  /**
+   * 标准化内容（去掉时间戳等动态部分）
+   */
+  normalizeContent(content) {
+    return content.replace(/\/\/ Generated at: .+/g, "").replace(/\/\*\* Generated at: .+ \*\//g, "");
+  }
+};
+
+// src/generator/plugin.ts
+var YwkfGeneratorPlugin = class {
+  options;
+  hasGenerated = false;
+  isWatching = false;
+  generator = null;
+  pluginHooks = [];
+  initialized = false;
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * 解析插件配置为插件实例
+   */
+  async resolvePlugin(pluginConfig) {
+    try {
+      let plugin;
+      let options = {};
+      if (typeof pluginConfig === "string") {
+        const module = await import(pluginConfig);
+        plugin = module.default || module;
+      } else if (Array.isArray(pluginConfig)) {
+        const [pluginOrName, pluginOptions] = pluginConfig;
+        options = pluginOptions;
+        if (typeof pluginOrName === "string") {
+          const module = await import(pluginOrName);
+          plugin = module.default || module;
+        } else {
+          plugin = pluginOrName;
+        }
+      } else {
+        plugin = pluginConfig;
+      }
+      if (typeof plugin === "function") {
+        plugin = plugin(options);
+      }
+      return plugin;
+    } catch (error) {
+      console.error(`[ywkf] \u89E3\u6790\u63D2\u4EF6\u5931\u8D25: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * 初始化插件钩子
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    const { cwd, config, isDev, pluginConfigs = [] } = this.options;
+    const context = {
+      cwd,
+      isDev,
+      isProd: !isDev,
+      config,
+      logger: {
+        info: (msg) => console.log(`[ywkf] ${msg}`),
+        warn: (msg) => console.warn(`[ywkf] ${msg}`),
+        error: (msg) => console.error(`[ywkf] ${msg}`),
+        debug: (msg) => {
+          if (process.env.DEBUG) {
+            console.log(`[ywkf:debug] ${msg}`);
+          }
+        }
+      }
+    };
+    for (const pluginConfig of pluginConfigs) {
+      const plugin = await this.resolvePlugin(pluginConfig);
+      if (plugin) {
+        const hooks = await plugin.setup(context);
+        this.pluginHooks.push(hooks);
+        console.log(`[ywkf] \u63D2\u4EF6\u5DF2\u52A0\u8F7D: ${plugin.name}`);
+      }
+    }
+    this.generator = new YwkfGenerator(
+      {
+        cwd: this.options.cwd,
+        config: this.options.config,
+        outputDir: this.options.outputDir,
+        isDev: this.options.isDev
+      },
+      this.pluginHooks
+    );
+    this.initialized = true;
+  }
+  apply(compiler) {
+    const pluginName = "YwkfGeneratorPlugin";
+    compiler.hooks.beforeCompile.tapAsync(pluginName, async (params, callback) => {
+      try {
+        await this.initialize();
+        if (!this.hasGenerated && this.generator) {
+          await this.generator.generate();
+          this.hasGenerated = true;
+        }
+        callback();
+      } catch (error) {
+        callback(error);
+      }
+    });
+    if (this.options.isDev && !this.isWatching) {
+      this.watchPages();
+    }
+  }
+  /**
+   * 监听页面目录变化
+   */
+  watchPages() {
+    const { config, cwd } = this.options;
+    const pagesDir = join4(cwd, config.router.pagesDir || "src/pages");
+    if (!existsSync5(pagesDir)) {
+      return;
+    }
+    this.isWatching = true;
+    let debounceTimer = null;
+    const watcher = watch(
+      pagesDir,
+      { recursive: true },
+      (eventType, filename) => {
+        if (!filename?.match(/\.(tsx?|jsx?)$/)) {
+          return;
+        }
+        if (debounceTimer) {
+          clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(async () => {
+          console.log(`[ywkf] \u68C0\u6D4B\u5230\u9875\u9762\u53D8\u5316: ${filename}`);
+          if (this.generator) {
+            await this.generator.generate();
+          }
+        }, 500);
+      }
+    );
+    process.on("exit", () => {
+      watcher.close();
+    });
+  }
+};
+
+// src/rspack/base.ts
+var require2 = createRequire(import.meta.url);
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var coreNodeModules = join5(__dirname, "../../node_modules");
+function createBaseConfig(config, cwd) {
+  const { resolveApp } = createPathResolver(cwd);
+  const {
+    appName,
+    appCName,
+    output,
+    html,
+    alias: userAlias,
+    microFrontend,
+    router
+  } = config;
+  const ywkfOutputDir = resolveApp(".ywkf");
+  const defaultAlias = {
+    "@": resolveApp("src"),
+    "@config": resolveApp("config"),
+    "@store": resolveApp("store"),
+    "@locales": resolveApp("locales"),
+    "@public": resolveApp("public"),
+    // 约定式路由生成的文件
+    "@ywkf/routes": join5(ywkfOutputDir, "routes.tsx"),
+    // 请求层（由 reactQueryPlugin 生成）
+    "@ywkf/request": join5(ywkfOutputDir, "request.ts"),
+    // Store 工具（由 zustandPlugin 生成）
+    "@ywkf/store": join5(ywkfOutputDir, "store.ts")
+  };
+  const alias = { ...defaultAlias, ...userAlias };
+  return {
+    // 使用 .ywkf/index.tsx 作为入口（由框架生成）
+    entry: [join5(ywkfOutputDir, "index.tsx")],
+    resolve: {
+      extensions: [".ts", ".tsx", ".jsx", ".js", ".json", ".mjs"],
+      symlinks: false,
+      alias: {
+        ...alias,
+        "process/browser.js": require2.resolve("process/browser.js"),
+        "process/browser": require2.resolve("process/browser.js"),
+        // 确保 React 系列包从用户项目的 node_modules 解析
+        react: resolveApp("node_modules/react"),
+        "react-dom": resolveApp("node_modules/react-dom"),
+        "react-router": resolveApp("node_modules/react-router")
+      },
+      fallback: {
+        path: require2.resolve("path-browserify"),
+        process: require2.resolve("process/browser.js"),
+        buffer: require2.resolve("buffer/"),
+        util: require2.resolve("util/"),
+        stream: require2.resolve("stream-browserify"),
+        crypto: require2.resolve("crypto-browserify"),
+        zlib: require2.resolve("browserify-zlib"),
+        querystring: require2.resolve("querystring-es3"),
+        url: require2.resolve("url/"),
+        assert: require2.resolve("assert/"),
+        fs: false,
+        net: false,
+        tls: false,
+        os: false,
+        https: false,
+        http: false
+      }
+    },
+    resolveLoader: {
+      modules: [coreNodeModules, "node_modules"]
+    },
+    module: {
+      rules: [
+        {
+          test: /\.m?js$/,
+          resolve: {
+            fullySpecified: false
+          }
+        },
+        {
+          test: /\.[jt]sx?$/,
+          include: [
+            resolveApp("src"),
+            resolveApp("config"),
+            resolveApp("store"),
+            resolveApp("packages"),
+            ywkfOutputDir
+            // 约定式路由生成的文件
+          ],
+          exclude: [resolveApp("node_modules")],
+          use: [
+            {
+              loader: "builtin:swc-loader",
+              options: {
+                jsc: {
+                  parser: {
+                    syntax: "typescript",
+                    tsx: true,
+                    decorators: true
+                  },
+                  transform: {
+                    react: {
+                      runtime: "automatic"
+                    }
+                  },
+                  target: "es2015"
+                },
+                sourceMaps: true
+              }
+            }
+          ]
+        },
+        {
+          test: /\.(png|jpg|jpeg|gif|webp|m3u8|exr|hdr|json|woff2)$/,
+          include: [resolveApp("public")],
+          exclude: [resolveApp("src"), resolveApp("store")],
+          type: "asset",
+          parser: {
+            dataUrlCondition: {
+              maxSize: 10 * 1024
+            }
+          }
+        },
+        {
+          test: /\.(md)$/,
+          include: [resolveApp("src")],
+          type: "asset/source"
+        },
+        {
+          test: /\.svg$/,
+          use: ["@svgr/webpack"]
+        }
+      ]
+    },
+    plugins: [
+      new rspack.ProvidePlugin({
+        process: "process/browser.js",
+        Buffer: ["buffer", "Buffer"]
+      }),
+      new rspack.DefinePlugin({
+        "process.env": JSON.stringify(process.env)
+      }),
+      new rspack.HtmlRspackPlugin({
+        template: resolveApp(html.template ?? "public/index.html"),
+        filename: "index.html",
+        inject: "body",
+        hash: true,
+        minify: process.env.NODE_ENV === "production",
+        favicon: resolveApp(html.favicon ?? "public/favicon.ico"),
+        templateParameters: {
+          title: html.title ?? appCName,
+          mountRoot: html.mountRoot ?? appName
+        }
+      }),
+      new rspack.CopyRspackPlugin({
+        patterns: [
+          {
+            from: resolveApp("public/images"),
+            to: "public/images",
+            noErrorOnMissing: true
+          }
+        ]
+      }),
+      // .ywkf 目录生成插件（传递用户配置的插件列表）
+      new YwkfGeneratorPlugin({
+        cwd,
+        config,
+        outputDir: ywkfOutputDir,
+        isDev: process.env.NODE_ENV !== "production",
+        pluginConfigs: config.plugins
+      })
+    ].filter(Boolean),
+    output: {
+      assetModuleFilename: "images/[hash][ext]",
+      library: microFrontend.enabled ? `${appCName}-[name]` : void 0,
+      chunkFilename: "[name].[contenthash].js",
+      libraryTarget: microFrontend.enabled ? "umd" : void 0,
+      globalObject: microFrontend.enabled ? "window" : void 0,
+      chunkLoadingGlobal: microFrontend.enabled ? `chunk_global_${appName}` : void 0,
+      publicPath: output.publicPath ?? "/",
+      path: resolveApp(output.path ?? "dist")
+    },
+    ignoreWarnings: [
+      {
+        module: /@testing-library\/react/,
+        message: /export 'act'/
+      }
+    ],
+    devtool: "source-map"
+  };
+}
+
+// src/rspack/dev.ts
+var require3 = createRequire2(import.meta.url);
+function convertProxyToArray(proxy) {
+  if (!proxy || Object.keys(proxy).length === 0) {
+    return void 0;
+  }
+  return Object.entries(proxy).map(([context, target]) => {
+    if (typeof target === "string") {
+      return {
+        context: [context],
+        target,
+        changeOrigin: true,
+        secure: false
+      };
+    }
+    return {
+      context: [context],
+      changeOrigin: true,
+      secure: false,
+      ...target
+    };
+  });
+}
+function createDevConfig(config, cwd) {
+  const baseConfig = createBaseConfig(config, cwd);
+  const { resolveApp } = createPathResolver(cwd);
+  const { dev: dev2, style } = config;
+  const styleRules = {
+    rules: [
+      // Less - antd
+      {
+        test: /\.less$/,
+        include: [
+          /[\\/]node_modules[\\/].*antd/,
+          /[\\/]node_modules[\\/]@4399ywkf[\\/]design/
+        ],
+        use: [
+          { loader: "style-loader" },
+          {
+            loader: "css-loader",
+            options: { sourceMap: true }
+          },
+          {
+            loader: "less-loader",
+            options: {
+              sourceMap: true,
+              lessOptions: {
+                strictMath: false,
+                math: "always",
+                javascriptEnabled: true
+              }
+            }
+          }
+        ]
+      },
+      // Less - 项目文件
+      ...style.less?.enabled !== false ? [
+        {
+          test: /\.less$/,
+          include: [resolveApp("src")],
+          exclude: [resolveApp("node_modules")],
+          oneOf: [
+            {
+              test: /\.module\.less$/,
+              use: [
+                { loader: "style-loader" },
+                {
+                  loader: "css-loader",
+                  options: {
+                    sourceMap: true,
+                    modules: {
+                      localIdentName: "[path][name]__[local]--[hash:base64:5]"
+                    },
+                    importLoaders: 2
+                  }
+                },
+                {
+                  loader: "less-loader",
+                  options: {
+                    sourceMap: true,
+                    lessOptions: {
+                      javascriptEnabled: true,
+                      math: "always",
+                      ...style.less?.lessOptions
+                    }
+                  }
+                }
+              ]
+            },
+            {
+              use: [
+                { loader: "style-loader" },
+                {
+                  loader: "css-loader",
+                  options: { sourceMap: true }
+                },
+                {
+                  loader: "less-loader",
+                  options: {
+                    sourceMap: true,
+                    lessOptions: {
+                      javascriptEnabled: true,
+                      ...style.less?.lessOptions
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      ] : [],
+      // Sass
+      ...style.sass?.enabled !== false ? [
+        {
+          test: /\.s[ac]ss$/i,
+          include: [resolveApp("src")],
+          exclude: [resolveApp("node_modules")],
+          oneOf: [
+            {
+              test: /\.module\.s[ac]ss$/,
+              use: [
+                { loader: "style-loader" },
+                {
+                  loader: "css-loader",
+                  options: {
+                    sourceMap: true,
+                    modules: {
+                      localIdentName: "[path][name]__[local]--[hash:base64:5]"
+                    },
+                    importLoaders: 2
+                  }
+                },
+                {
+                  loader: "sass-loader",
+                  options: {
+                    sourceMap: true,
+                    sassOptions: {
+                      outputStyle: "compressed",
+                      ...style.sass?.sassOptions
+                    }
+                  }
+                }
+              ]
+            },
+            {
+              use: [
+                { loader: "style-loader" },
+                {
+                  loader: "css-loader",
+                  options: { sourceMap: true }
+                },
+                {
+                  loader: "sass-loader",
+                  options: {
+                    sourceMap: true,
+                    sassOptions: {
+                      outputStyle: "compressed",
+                      ...style.sass?.sassOptions
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      ] : [],
+      // TailwindCSS
+      ...style.tailwindcss ? [
+        {
+          test: /\.css$/,
+          include: [resolveApp("src/index.css")],
+          use: [
+            "style-loader",
+            "css-loader",
+            {
+              loader: "postcss-loader",
+              options: {
+                postcssOptions: {
+                  config: resolveApp("postcss.config.js")
+                }
+              }
+            }
+          ]
+        }
+      ] : [],
+      // 其他 CSS
+      {
+        test: /\.css$/,
+        include: [resolveApp("src"), resolveApp("node_modules")],
+        exclude: style.tailwindcss ? [resolveApp("src/index.css")] : [],
+        use: [
+          { loader: "style-loader" },
+          {
+            loader: "css-loader",
+            options: { sourceMap: true }
+          }
+        ]
+      }
+    ]
+  };
+  const devConfig = {
+    mode: "development",
+    devtool: "inline-source-map",
+    output: {
+      filename: "[name].bundle.js",
+      clean: false
+    },
+    stats: "errors-only",
+    devServer: {
+      host: dev2.host,
+      port: dev2.port,
+      compress: true,
+      historyApiFallback: true,
+      hot: true,
+      allowedHosts: "all",
+      client: {
+        overlay: false,
+        progress: true
+      },
+      proxy: convertProxyToArray(dev2.proxy)
+    },
+    module: styleRules
+  };
+  return merge(baseConfig, devConfig);
+}
+
+// src/rspack/prod.ts
+import { rspack as rspack2 } from "@rspack/core";
+import { merge as merge2 } from "webpack-merge";
+function createProdConfig(config, cwd) {
+  const baseConfig = createBaseConfig(config, cwd);
+  const { resolveApp } = createPathResolver(cwd);
+  const { style, performance, output } = config;
+  const styleRules = {
+    rules: [
+      // Less - antd
+      {
+        test: /\.less$/,
+        include: [
+          /[\\/]node_modules[\\/].*antd/,
+          /[\\/]node_modules[\\/]@4399ywkf[\\/]design/
+        ],
+        use: [
+          { loader: rspack2.CssExtractRspackPlugin.loader },
+          {
+            loader: "css-loader",
+            options: { sourceMap: true }
+          },
+          {
+            loader: "less-loader",
+            options: {
+              sourceMap: true,
+              lessOptions: {
+                strictMath: false,
+                math: "always",
+                javascriptEnabled: true
+              }
+            }
+          }
+        ]
+      },
+      // Less - 项目文件
+      ...style.less?.enabled !== false ? [
+        {
+          test: /\.less$/,
+          include: [resolveApp("src")],
+          exclude: [resolveApp("node_modules")],
+          oneOf: [
+            {
+              test: /\.module\.less$/,
+              use: [
+                { loader: rspack2.CssExtractRspackPlugin.loader },
+                {
+                  loader: "css-loader",
+                  options: {
+                    sourceMap: true,
+                    modules: {
+                      localIdentName: "[path][name]__[local]--[hash:base64:5]"
+                    },
+                    importLoaders: 2
+                  }
+                },
+                {
+                  loader: "less-loader",
+                  options: {
+                    sourceMap: true,
+                    lessOptions: {
+                      javascriptEnabled: true,
+                      ...style.less?.lessOptions
+                    }
+                  }
+                }
+              ]
+            },
+            {
+              use: [
+                { loader: rspack2.CssExtractRspackPlugin.loader },
+                {
+                  loader: "css-loader",
+                  options: { sourceMap: true }
+                },
+                {
+                  loader: "less-loader",
+                  options: {
+                    sourceMap: true,
+                    lessOptions: {
+                      javascriptEnabled: true,
+                      ...style.less?.lessOptions
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      ] : [],
+      // Sass
+      ...style.sass?.enabled !== false ? [
+        {
+          test: /\.s[ac]ss$/i,
+          include: [resolveApp("src")],
+          exclude: [resolveApp("node_modules")],
+          oneOf: [
+            {
+              test: /\.module\.s[ac]ss$/,
+              use: [
+                { loader: rspack2.CssExtractRspackPlugin.loader },
+                {
+                  loader: "css-loader",
+                  options: {
+                    sourceMap: true,
+                    modules: {
+                      localIdentName: "[path][name]__[local]--[hash:base64:5]"
+                    },
+                    importLoaders: 2
+                  }
+                },
+                {
+                  loader: "sass-loader",
+                  options: {
+                    sourceMap: true,
+                    sassOptions: {
+                      outputStyle: "compressed",
+                      ...style.sass?.sassOptions
+                    }
+                  }
+                }
+              ]
+            },
+            {
+              use: [
+                { loader: rspack2.CssExtractRspackPlugin.loader },
+                {
+                  loader: "css-loader",
+                  options: { sourceMap: true }
+                },
+                {
+                  loader: "sass-loader",
+                  options: {
+                    sourceMap: true,
+                    sassOptions: {
+                      outputStyle: "compressed",
+                      ...style.sass?.sassOptions
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      ] : [],
+      // TailwindCSS
+      ...style.tailwindcss ? [
+        {
+          test: /\.css$/,
+          include: [resolveApp("src/index.css")],
+          use: [
+            { loader: rspack2.CssExtractRspackPlugin.loader },
+            "css-loader",
+            {
+              loader: "postcss-loader",
+              options: {
+                postcssOptions: {
+                  config: resolveApp("postcss.config.js")
+                }
+              }
+            }
+          ]
+        }
+      ] : [],
+      // src 目录中的其他 CSS
+      {
+        test: /\.css$/,
+        include: [resolveApp("src")],
+        exclude: style.tailwindcss ? [resolveApp("src/index.css")] : [],
+        use: [
+          { loader: rspack2.CssExtractRspackPlugin.loader },
+          {
+            loader: "css-loader",
+            options: { sourceMap: true }
+          }
+        ]
+      },
+      // node_modules CSS
+      {
+        test: /\.css$/,
+        include: [resolveApp("node_modules")],
+        use: [
+          { loader: "style-loader" },
+          {
+            loader: "css-loader",
+            options: { sourceMap: true }
+          }
+        ]
+      }
+    ]
+  };
+  const prodConfig = {
+    mode: "production",
+    devtool: "hidden-source-map",
+    output: {
+      filename: "[name].[contenthash].bundle.js",
+      chunkFilename: "[name].[contenthash].chunk.js",
+      clean: output.clean
+    },
+    module: styleRules,
+    plugins: [
+      new rspack2.CssExtractRspackPlugin({
+        filename: "[name].[contenthash:8].css",
+        chunkFilename: "[name].[contenthash:8].chunk.css"
+      })
+    ],
+    optimization: {
+      minimize: true,
+      minimizer: [
+        new rspack2.SwcJsMinimizerRspackPlugin({
+          exclude: [resolveApp("node_modules")],
+          minimizerOptions: {
+            compress: {
+              pure_funcs: performance.dropConsole ? ["console.log", "console.info", "console.debug", "console.warn"] : ["console.info", "console.debug"],
+              drop_console: false,
+              drop_debugger: true
+            }
+          }
+        }),
+        new rspack2.LightningCssMinimizerRspackPlugin()
+      ]
+    }
+  };
+  return merge2(baseConfig, prodConfig);
+}
+
+// src/rspack/index.ts
+function createRspackConfig(config, cwd, options = {}) {
+  const isDev = options.isDev ?? process.env.NODE_ENV !== "production";
+  let rspackConfig = isDev ? createDevConfig(config, cwd) : createProdConfig(config, cwd);
+  if (config.performance.rsdoctor) {
+    rspackConfig.plugins = [
+      ...rspackConfig.plugins || [],
+      new RsdoctorRspackPlugin({})
+    ];
+  }
+  if (config.tools.rspack) {
+    const userConfig = config.tools.rspack(rspackConfig, {
+      isDev,
+      isProd: !isDev
+    });
+    if (userConfig) {
+      rspackConfig = userConfig;
+    }
+  }
+  return rspackConfig;
+}
+
+// src/router/plugin.ts
+import { join as join6 } from "path";
+import { watch as watch2, existsSync as existsSync6 } from "fs";
+var ConventionalRoutePlugin = class {
+  options;
+  isWatching = false;
+  hasGenerated = false;
+  lastGeneratedContent = "";
+  constructor(options) {
+    this.options = options;
+  }
+  apply(compiler) {
+    const pluginName = "ConventionalRoutePlugin";
+    compiler.hooks.beforeCompile.tapAsync(pluginName, (params, callback) => {
+      if (!this.hasGenerated) {
+        this.generateRoutes();
+        this.hasGenerated = true;
+      }
+      callback();
+    });
+    if (this.options.watch && !this.isWatching) {
+      this.watchPages();
+    }
+  }
+  /**
+   * 生成路由文件（带内容比对，避免不必要的重复生成）
+   */
+  generateRoutes() {
+    try {
+      const generator = new ConventionalRouteGenerator({
+        pagesDir: this.options.pagesDir,
+        outputDir: this.options.outputDir,
+        basename: this.options.basename
+      });
+      const newContent = generator.generateCode();
+      const outputPath = join6(this.options.outputDir, "routes.tsx");
+      const normalizedNew = this.normalizeContent(newContent);
+      const normalizedOld = this.normalizeContent(this.lastGeneratedContent);
+      if (normalizedNew === normalizedOld) {
+        return;
+      }
+      generator.write();
+      this.lastGeneratedContent = newContent;
+    } catch (error) {
+      console.error("[ywkf] \u751F\u6210\u8DEF\u7531\u5931\u8D25:", error);
+    }
+  }
+  /**
+   * 标准化内容（去掉时间戳等动态部分）
+   */
+  normalizeContent(content) {
+    return content.replace(/\/\/ Generated at: .+/g, "");
+  }
+  /**
+   * 监听页面目录变化
+   */
+  watchPages() {
+    if (!existsSync6(this.options.pagesDir)) {
+      return;
+    }
+    this.isWatching = true;
+    let debounceTimer = null;
+    const watcher = watch2(
+      this.options.pagesDir,
+      { recursive: true },
+      (eventType, filename) => {
+        if (!filename?.match(/\.(tsx?|jsx?)$/)) {
+          return;
+        }
+        if (debounceTimer) {
+          clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(() => {
+          console.log(`[ywkf] \u68C0\u6D4B\u5230\u9875\u9762\u53D8\u5316: ${filename}`);
+          this.generateRoutes();
+        }, 500);
+      }
+    );
+    process.on("exit", () => {
+      watcher.close();
+    });
+  }
+};
+
+// src/runtime/context.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var defaultContextValue = {
+  appName: "app",
+  basename: "/",
+  isDev: process.env.NODE_ENV === "development",
+  env: {}
+};
+var AppContext = createContext(defaultContextValue);
+function AppContextProvider({
+  value,
+  children
+}) {
+  const contextValue = {
+    ...defaultContextValue,
+    ...value,
+    env: {
+      ...defaultContextValue.env,
+      ...value.env
+    }
+  };
+  return /* @__PURE__ */ jsx(AppContext.Provider, { value: contextValue, children });
+}
+function useApp() {
+  const context = useContext(AppContext);
+  if (!context) {
+    throw new Error("useApp must be used within AppContextProvider");
+  }
+  return context;
+}
+function useAppName() {
+  return useApp().appName;
+}
+function useBasename() {
+  return useApp().basename;
+}
+function useEnv() {
+  return useApp().env;
+}
+function useIsDev() {
+  return useApp().isDev;
+}
+
+// src/runtime/error-boundary.tsx
+import { Component } from "react";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var ErrorBoundary = class extends Component {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false, error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    console.error("[ErrorBoundary] Caught error:", error, errorInfo);
+    this.props.onError?.(error, errorInfo);
+  }
+  reset = () => {
+    this.setState({ hasError: false, error: null });
+  };
+  render() {
+    const { hasError, error } = this.state;
+    const { children, fallback } = this.props;
+    if (hasError && error) {
+      if (typeof fallback === "function") {
+        return fallback(error, this.reset);
+      }
+      if (fallback) {
+        return fallback;
+      }
+      return /* @__PURE__ */ jsx2(DefaultErrorFallback, { error, onReset: this.reset });
+    }
+    return children;
+  }
+};
+function DefaultErrorFallback({ error, onReset }) {
+  const isDev = process.env.NODE_ENV === "development";
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      style: {
+        padding: 24,
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        minHeight: "100vh",
+        backgroundColor: "#f5f5f5"
+      },
+      children: /* @__PURE__ */ jsxs(
+        "div",
+        {
+          style: {
+            maxWidth: 600,
+            padding: 32,
+            backgroundColor: "#fff",
+            borderRadius: 8,
+            boxShadow: "0 2px 8px rgba(0,0,0,0.1)"
+          },
+          children: [
+            /* @__PURE__ */ jsx2("h1", { style: { color: "#ff4d4f", marginBottom: 16 }, children: "\u9875\u9762\u51FA\u9519\u4E86" }),
+            /* @__PURE__ */ jsx2("p", { style: { color: "#666", marginBottom: 16 }, children: "\u62B1\u6B49\uFF0C\u9875\u9762\u9047\u5230\u4E86\u4E00\u4E9B\u95EE\u9898\u3002\u8BF7\u5C1D\u8BD5\u5237\u65B0\u9875\u9762\u6216\u8054\u7CFB\u7BA1\u7406\u5458\u3002" }),
+            isDev && /* @__PURE__ */ jsxs(
+              "details",
+              {
+                style: {
+                  marginBottom: 16,
+                  padding: 12,
+                  backgroundColor: "#fff2f0",
+                  borderRadius: 4,
+                  border: "1px solid #ffccc7"
+                },
+                children: [
+                  /* @__PURE__ */ jsx2("summary", { style: { cursor: "pointer", fontWeight: "bold" }, children: "\u9519\u8BEF\u8BE6\u60C5\uFF08\u4EC5\u5F00\u53D1\u73AF\u5883\u53EF\u89C1\uFF09" }),
+                  /* @__PURE__ */ jsxs(
+                    "pre",
+                    {
+                      style: {
+                        marginTop: 8,
+                        padding: 8,
+                        backgroundColor: "#fff",
+                        borderRadius: 4,
+                        overflow: "auto",
+                        fontSize: 12
+                      },
+                      children: [
+                        error.message,
+                        "\n\n",
+                        error.stack
+                      ]
+                    }
+                  )
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: 8 }, children: [
+              /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  onClick: onReset,
+                  style: {
+                    padding: "8px 16px",
+                    backgroundColor: "#1890ff",
+                    color: "#fff",
+                    border: "none",
+                    borderRadius: 4,
+                    cursor: "pointer"
+                  },
+                  children: "\u91CD\u8BD5"
+                }
+              ),
+              /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  onClick: () => window.location.reload(),
+                  style: {
+                    padding: "8px 16px",
+                    backgroundColor: "#fff",
+                    color: "#666",
+                    border: "1px solid #d9d9d9",
+                    borderRadius: 4,
+                    cursor: "pointer"
+                  },
+                  children: "\u5237\u65B0\u9875\u9762"
+                }
+              )
+            ] })
+          ]
+        }
+      )
+    }
+  );
+}
+
+// src/runtime/providers.tsx
+import {
+  StrictMode,
+  Suspense
+} from "react";
+import { RouterProvider } from "react-router";
+import { ConfigProvider } from "antd";
+import zhCN from "antd/locale/zh_CN.js";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function DefaultLoading() {
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      style: {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        height: "100vh",
+        fontSize: 16,
+        color: "#999"
+      },
+      children: "\u52A0\u8F7D\u4E2D..."
+    }
+  );
+}
+function composeProviders(providers) {
+  const sortedProviders = [...providers].sort(
+    (a, b) => (a.order ?? 100) - (b.order ?? 100)
+  );
+  return function ComposedProviders({ children }) {
+    return sortedProviders.reduceRight((acc, { component: Provider, props }) => {
+      return /* @__PURE__ */ jsx3(Provider, { ...props, children: acc });
+    }, children);
+  };
+}
+function RootProvider({ config, children }) {
+  const {
+    appName = "app",
+    router,
+    basename: basename2 = "/",
+    strictMode = true,
+    antd = { enabled: true },
+    providers = [],
+    lifecycle
+  } = config;
+  const appContextValue = {
+    appName,
+    basename: basename2,
+    isDev: process.env.NODE_ENV === "development",
+    env: typeof process !== "undefined" ? process.env : {}
+  };
+  const allProviders = [
+    // 应用上下文 Provider（最外层）
+    {
+      component: AppContextProvider,
+      props: { value: appContextValue },
+      order: 0
+    },
+    // Ant Design ConfigProvider
+    ...antd.enabled !== false ? [
+      {
+        component: ConfigProvider,
+        props: {
+          locale: antd.locale || zhCN,
+          theme: antd.theme,
+          ...antd.configProvider
+        },
+        order: 10
+      }
+    ] : [],
+    // 用户自定义 Providers
+    ...providers.map((p) => ({ ...p, order: p.order ?? 50 }))
+  ];
+  const ComposedProviders = composeProviders(allProviders);
+  const content = router ? /* @__PURE__ */ jsx3(Suspense, { fallback: /* @__PURE__ */ jsx3(DefaultLoading, {}), children: /* @__PURE__ */ jsx3(RouterProvider, { router }) }) : children;
+  const app = /* @__PURE__ */ jsx3(ErrorBoundary, { onError: lifecycle?.onError, children: /* @__PURE__ */ jsx3(ComposedProviders, { children: content }) });
+  if (strictMode) {
+    return /* @__PURE__ */ jsx3(StrictMode, { children: app });
+  }
+  return app;
+}
+function createProvider(component, props, order) {
+  return {
+    component,
+    props,
+    order
+  };
+}
+
+// src/runtime/bootstrap.tsx
+import { createRoot } from "react-dom/client";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var root = null;
+async function resolveAppConfig(config) {
+  if (config.router || !config.conventionalRoutes) {
+    return config;
+  }
+  try {
+    const routesModule = await import("@ywkf/routes");
+    const createRouter = routesModule.createRouter || routesModule.default?.createRouter;
+    if (typeof createRouter === "function") {
+      const router = createRouter(config.basename);
+      console.log("[ywkf] \u5DF2\u81EA\u52A8\u6CE8\u5165\u7EA6\u5B9A\u5F0F\u8DEF\u7531");
+      return { ...config, router };
+    } else {
+      console.warn("[ywkf] @ywkf/routes \u672A\u5BFC\u51FA createRouter \u51FD\u6570");
+    }
+  } catch (error) {
+    console.error("[ywkf] \u52A0\u8F7D\u7EA6\u5B9A\u5F0F\u8DEF\u7531\u5931\u8D25:", error);
+    console.warn("[ywkf] \u8BF7\u786E\u4FDD\u5DF2\u542F\u7528\u7EA6\u5B9A\u5F0F\u8DEF\u7531\u4E14 src/pages \u76EE\u5F55\u5B58\u5728");
+  }
+  return config;
+}
+async function bootstrap(config) {
+  const { rootId = "root", lifecycle } = config;
+  const resolvedConfig = await resolveAppConfig(config);
+  if (lifecycle?.onBeforeMount) {
+    await lifecycle.onBeforeMount();
+  }
+  const rootElement = document.getElementById(rootId);
+  if (!rootElement) {
+    throw new Error(`\u627E\u4E0D\u5230\u6839\u5143\u7D20 #${rootId}`);
+  }
+  root = createRoot(rootElement);
+  root.render(/* @__PURE__ */ jsx4(RootProvider, { config: resolvedConfig }));
+  if (lifecycle?.onMounted) {
+    setTimeout(() => {
+      lifecycle.onMounted?.();
+    }, 0);
+  }
+  if (lifecycle?.onUnmount) {
+    window.addEventListener("beforeunload", () => {
+      lifecycle.onUnmount?.();
+    });
+  }
+}
+function unmount() {
+  if (root) {
+    root.unmount();
+    root = null;
+  }
+}
+function createMicroApp(getConfig) {
+  let microRoot = null;
+  return {
+    /**
+     * 微前端 bootstrap 生命周期
+     */
+    async bootstrap() {
+      console.log("[MicroApp] bootstrap");
+    },
+    /**
+     * 微前端 mount 生命周期
+     */
+    async mount(props) {
+      console.log("[MicroApp] mount", props);
+      const config = getConfig(props);
+      const resolvedConfig = await resolveAppConfig(config);
+      const container = props?.masterProps?.container;
+      const rootId = resolvedConfig.rootId || "root";
+      const rootElement = container ? container.querySelector(`#${rootId}`) : document.getElementById(rootId);
+      if (!rootElement) {
+        throw new Error(`[MicroApp] \u627E\u4E0D\u5230\u6839\u5143\u7D20 #${rootId}`);
+      }
+      if (resolvedConfig.lifecycle?.onBeforeMount) {
+        await resolvedConfig.lifecycle.onBeforeMount();
+      }
+      microRoot = createRoot(rootElement);
+      microRoot.render(/* @__PURE__ */ jsx4(RootProvider, { config: resolvedConfig }));
+      if (resolvedConfig.lifecycle?.onMounted) {
+        setTimeout(() => {
+          resolvedConfig.lifecycle?.onMounted?.();
+        }, 0);
+      }
+    },
+    /**
+     * 微前端 unmount 生命周期
+     */
+    async unmount(props) {
+      console.log("[MicroApp] unmount", props);
+      const config = getConfig(props);
+      if (config.lifecycle?.onUnmount) {
+        config.lifecycle.onUnmount();
+      }
+      if (microRoot) {
+        microRoot.unmount();
+        microRoot = null;
+      }
+    },
+    /**
+     * 微前端 update 生命周期（可选）
+     */
+    async update(props) {
+      console.log("[MicroApp] update", props);
+    }
+  };
+}
+function isMicroAppEnv() {
+  if (window.__POWERED_BY_QIANKUN__) {
+    return true;
+  }
+  if (window.__GARFISH__) {
+    return true;
+  }
+  return false;
+}
+function getMicroAppPublicPath() {
+  if (window.__INJECTED_PUBLIC_PATH_BY_QIANKUN__) {
+    return window.__INJECTED_PUBLIC_PATH_BY_QIANKUN__;
+  }
+  return "/";
+}
+
+// src/plugin/define.ts
+function definePlugin(plugin) {
+  return plugin;
+}
+function createPlugin(factory) {
+  return factory;
+}
+
+// src/plugin/manager.ts
+function createLogger(pluginName) {
+  const prefix = `[${pluginName}]`;
+  return {
+    info: (msg) => console.log(`${prefix} ${msg}`),
+    warn: (msg) => console.warn(`${prefix} ${msg}`),
+    error: (msg) => console.error(`${prefix} ${msg}`),
+    debug: (msg) => {
+      if (process.env.DEBUG) {
+        console.debug(`${prefix} ${msg}`);
+      }
+    }
+  };
+}
+async function resolvePlugin(pluginConfig, cwd) {
+  let plugin;
+  let options = {};
+  if (typeof pluginConfig === "string") {
+    const module = await import(pluginConfig);
+    plugin = module.default || module;
+  } else if (Array.isArray(pluginConfig)) {
+    const [pluginOrName, pluginOptions] = pluginConfig;
+    options = pluginOptions;
+    if (typeof pluginOrName === "string") {
+      const module = await import(pluginOrName);
+      plugin = module.default || module;
+    } else {
+      plugin = pluginOrName;
+    }
+  } else {
+    plugin = pluginConfig;
+  }
+  if (typeof plugin === "function") {
+    plugin = plugin(options);
+  }
+  return { plugin, options };
+}
+var PluginManager = class {
+  plugins = /* @__PURE__ */ new Map();
+  context;
+  constructor(config, cwd, isDev) {
+    this.context = {
+      cwd,
+      isDev,
+      isProd: !isDev,
+      config,
+      logger: createLogger("PluginManager")
+    };
+  }
+  /**
+   * 加载并初始化所有插件
+   */
+  async loadPlugins(pluginConfigs) {
+    for (const pluginConfig of pluginConfigs) {
+      try {
+        const { plugin } = await resolvePlugin(pluginConfig, this.context.cwd);
+        if (this.plugins.has(plugin.name)) {
+          this.context.logger.warn(`\u63D2\u4EF6 ${plugin.name} \u5DF2\u52A0\u8F7D\uFF0C\u8DF3\u8FC7\u91CD\u590D\u52A0\u8F7D`);
+          continue;
+        }
+        const pluginContext = {
+          ...this.context,
+          logger: createLogger(plugin.name)
+        };
+        const hooks = await plugin.setup(pluginContext);
+        this.plugins.set(plugin.name, { plugin, hooks });
+        this.context.logger.info(`\u5DF2\u52A0\u8F7D\u63D2\u4EF6: ${plugin.name}`);
+      } catch (error) {
+        this.context.logger.error(
+          `\u52A0\u8F7D\u63D2\u4EF6\u5931\u8D25: ${String(pluginConfig)} - ${error}`
+        );
+      }
+    }
+  }
+  /**
+   * 执行 modifyRspackConfig 钩子
+   */
+  async applyRspackConfigHooks(config) {
+    let result = config;
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.modifyRspackConfig) {
+        try {
+          const modified = await hooks.modifyRspackConfig(result, this.context);
+          if (modified) {
+            result = modified;
+          }
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} modifyRspackConfig \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * 执行 modifyRoutes 钩子
+   */
+  async applyRoutesHooks(routes) {
+    let result = routes;
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.modifyRoutes) {
+        try {
+          const modified = await hooks.modifyRoutes(result, this.context);
+          if (modified) {
+            result = modified;
+          }
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} modifyRoutes \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * 执行 modifyAppConfig 钩子
+   */
+  applyAppConfigHooks(appConfig) {
+    let result = appConfig;
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.modifyAppConfig) {
+        try {
+          const modified = hooks.modifyAppConfig(result, this.context);
+          if (modified) {
+            result = modified;
+          }
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} modifyAppConfig \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * 收集所有插件的 Provider
+   */
+  collectProviders() {
+    const providers = [];
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.addProvider) {
+        try {
+          const result = hooks.addProvider(this.context);
+          if (Array.isArray(result)) {
+            providers.push(...result);
+          } else if (result) {
+            providers.push(result);
+          }
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} addProvider \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+    return providers;
+  }
+  /**
+   * 执行 beforeBuild 钩子
+   */
+  async runBeforeBuild() {
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.beforeBuild) {
+        try {
+          await hooks.beforeBuild(this.context);
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} beforeBuild \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * 执行 afterBuild 钩子
+   */
+  async runAfterBuild(stats) {
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.afterBuild) {
+        try {
+          await hooks.afterBuild(this.context, stats);
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} afterBuild \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * 执行 beforeDevServer 钩子
+   */
+  async runBeforeDevServer() {
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.beforeDevServer) {
+        try {
+          await hooks.beforeDevServer(this.context);
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} beforeDevServer \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * 执行 afterDevServer 钩子
+   */
+  async runAfterDevServer(server) {
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.afterDevServer) {
+        try {
+          await hooks.afterDevServer(this.context, server);
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} afterDevServer \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * 获取所有已加载的插件名称
+   */
+  getPluginNames() {
+    return Array.from(this.plugins.keys());
+  }
+  /**
+   * 获取所有已加载的插件
+   */
+  getPlugins() {
+    return Array.from(this.plugins.values()).map((p) => p.plugin);
+  }
+  /**
+   * 获取所有已加载的插件钩子
+   */
+  getPluginHooks() {
+    return Array.from(this.plugins.values()).map((p) => p.hooks);
+  }
+};
+
+// 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}`
+          };
+          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) {
+          return {};
+        }
+        return {
+          imports: [
+            `import { microApp, isMicroAppEnv } from "./bootstrap";`
+          ],
+          exports: [
+            `// Garfish \u5FAE\u524D\u7AEF\u751F\u547D\u5468\u671F\u5BFC\u51FA`,
+            `export const { mount, unmount } = microApp;`,
+            `export const provider = microApp;`,
+            `export default microApp;`
+          ],
+          topLevel: [
+            `// Garfish \u5FAE\u524D\u7AEF\uFF1A\u72EC\u7ACB\u8FD0\u884C\u5224\u65AD`,
+            `const shouldRunIndependently = !isMicroAppEnv();`
+          ]
+        };
+      },
+      injectBootstrap(ctx) {
+        const imports = [
+          `import { createMicroApp, isMicroAppEnv } from "@4399ywkf/core/runtime";`
+        ];
+        const exports = [
+          `/**`,
+          ` * Garfish \u5FAE\u524D\u7AEF\u5E94\u7528\u5B9E\u4F8B`,
+          ` */`,
+          `export const microApp = createMicroApp(createAppConfig);`,
+          ``,
+          `/**`,
+          ` * \u5224\u65AD\u662F\u5426\u5728\u5FAE\u524D\u7AEF\u73AF\u5883`,
+          ` */`,
+          `export { isMicroAppEnv };`
+        ];
+        const topLevel = [];
+        if (master && apps.length > 0) {
+          imports.push(`import Garfish from "garfish";`);
+          topLevel.push(generateMasterInitCode(apps, config.router.basename));
+        }
+        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, basename2) {
+  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: "${basename2 || "/"}",
+    apps: [
+      ${appConfigs}
+    ],
+  });
+}
+`;
+}
+
+// src/plugin/builtin/tailwind.ts
+import { existsSync as existsSync7, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7 } from "path";
+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 = join7(cwd, "postcss.config.js");
+        const isProd = rspackConfig.mode === "production";
+        const tailwindRule = {
+          test: /tailwind\.css$/,
+          use: [
+            isProd ? "mini-css-extract-plugin/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 = join7(cwd, "postcss.config.js");
+  if (!existsSync7(configPath)) {
+    writeFileSync3(
+      configPath,
+      `module.exports = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+`,
+      "utf-8"
+    );
+    logger.info("\u5DF2\u81EA\u52A8\u751F\u6210 postcss.config.js");
+  }
+}
+
+// src/plugin/builtin/i18n.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { join as join8 } from "path";
+var i18nPlugin = createPlugin((options = {}) => ({
+  name: "@4399ywkf/plugin-i18n",
+  version: "1.0.0",
+  description: "\u56FD\u9645\u5316 (i18next) \u63D2\u4EF6",
+  setup(context) {
+    const {
+      defaultLocale = "zh-CN",
+      locales = ["zh-CN", "en-US"],
+      localesDir = "locales",
+      defaultNS = ["common"],
+      autoScaffold = true
+    } = options;
+    const { cwd, logger } = context;
+    if (autoScaffold) {
+      scaffoldLocaleFiles(cwd, localesDir, locales, defaultNS, logger);
+    }
+    const hooks = {
+      modifyRspackConfig(rspackConfig) {
+        const aliases = rspackConfig.resolve?.alias || {};
+        if (!aliases["@locales"]) {
+          aliases["@locales"] = join8(cwd, localesDir);
+          rspackConfig.resolve = { ...rspackConfig.resolve, alias: aliases };
+        }
+        return rspackConfig;
+      },
+      generateFiles(ctx) {
+        return [
+          {
+            path: "i18n.ts",
+            content: generateI18nCode(defaultLocale, locales, localesDir, defaultNS)
+          }
+        ];
+      },
+      injectBootstrap(ctx) {
+        return {
+          imports: [
+            `import { initI18n } from "./i18n";`
+          ],
+          topLevel: [
+            `// \u521D\u59CB\u5316 i18n\uFF08\u5728\u5E94\u7528\u542F\u52A8\u524D\uFF09`,
+            `await initI18n();`
+          ]
+        };
+      }
+    };
+    return hooks;
+  }
+}));
+function generateI18nCode(defaultLocale, locales, localesDir, defaultNS) {
+  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";
+
+export const DEFAULT_LOCALE = "${defaultLocale}";
+
+export const SUPPORTED_LOCALES = ${JSON.stringify(locales)} as const;
+
+export type SupportedLocale = typeof SUPPORTED_LOCALES[number];
+
+const instance = i18n
+  .use(initReactI18next)
+  .use(LanguageDetector)
+  .use(
+    resourcesToBackend(async (lng: string, ns: string) => {
+      return import(\`@locales/\${normalizeLocale(lng)}/\${ns}.json\`);
+    })
+  );
+
+function normalizeLocale(locale?: string): string {
+  if (!locale) return DEFAULT_LOCALE;
+  for (const l of SUPPORTED_LOCALES) {
+    if (l.startsWith(locale) || locale.startsWith(l.split("-")[0])) {
+      return l;
+    }
+  }
+  return DEFAULT_LOCALE;
+}
+
+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 scaffoldLocaleFiles(cwd, localesDir, locales, namespaces, logger) {
+  const baseDir = join8(cwd, localesDir);
+  for (const locale of locales) {
+    const localeDir = join8(baseDir, locale);
+    if (!existsSync8(localeDir)) {
+      mkdirSync3(localeDir, { recursive: true });
+    }
+    for (const ns of namespaces) {
+      const filePath = join8(localeDir, `${ns}.json`);
+      if (!existsSync8(filePath)) {
+        const isDefault = locale === locales[0];
+        const content = isDefault ? JSON.stringify({ welcome: "\u6B22\u8FCE\u4F7F\u7528" }, null, 2) : JSON.stringify({ welcome: "Welcome" }, null, 2);
+        writeFileSync4(filePath, content + "\n", "utf-8");
+        logger.info(`\u5DF2\u751F\u6210\u7FFB\u8BD1\u6587\u4EF6: ${localesDir}/${locale}/${ns}.json`);
+      }
+    }
+  }
+}
+
+// src/plugin/builtin/theme.ts
+var themePlugin = createPlugin((options = {}) => ({
+  name: "@4399ywkf/plugin-theme",
+  version: "1.0.0",
+  description: "antd-style \u4E3B\u9898\u7CFB\u7EDF\u63D2\u4EF6",
+  setup(context) {
+    const {
+      darkMode = true,
+      defaultAppearance = "auto",
+      primaryColor = "blue",
+      prefixCls = "ant",
+      cssVar = true,
+      globalReset = true
+    } = options;
+    const { logger } = context;
+    logger.info(`\u4E3B\u9898\u6A21\u5F0F: ${defaultAppearance}, \u4E3B\u8272: ${primaryColor}`);
+    const hooks = {
+      generateFiles(ctx) {
+        return [
+          {
+            path: "theme.tsx",
+            content: generateThemeProvider({
+              darkMode,
+              defaultAppearance,
+              primaryColor,
+              prefixCls,
+              cssVar,
+              globalReset
+            })
+          }
+        ];
+      },
+      injectBootstrap(ctx) {
+        return {
+          imports: [
+            `import { ThemeWrapper } from "./theme";`
+          ]
+        };
+      }
+      // Provider 由生成的 theme.tsx 文件在用户层使用
+      // 用户可以在 src/app.config.ts 中通过 providers 引入 ThemeWrapper
+    };
+    return hooks;
+  }
+}));
+function generateThemeProvider(opts) {
+  const { darkMode, defaultAppearance, primaryColor, prefixCls, cssVar, globalReset } = opts;
+  return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/plugin-theme \u81EA\u52A8\u751F\u6210
+import React, { useEffect, type ReactNode } from "react";
+import { ThemeProvider, createGlobalStyle } from "antd-style";
+
+${globalReset ? GLOBAL_RESET_CODE : ""}
+
+const DEFAULT_APPEARANCE = "${defaultAppearance}" as const;
+
+interface ThemeWrapperProps {
+  children: ReactNode;
+}
+
+/**
+ * \u4E3B\u9898\u5305\u88F9\u7EC4\u4EF6
+ * \u7531 themePlugin \u81EA\u52A8\u6CE8\u5165\u5230\u5E94\u7528\u542F\u52A8\u5C42
+ */
+export function ThemeWrapper({ children }: ThemeWrapperProps) {
+  ${darkMode ? DARK_MODE_EFFECT : ""}
+
+  return (
+    <ThemeProvider
+      prefixCls="${prefixCls}"
+      ${defaultAppearance !== "auto" ? `appearance="${defaultAppearance}"` : ""}
+      theme={{
+        cssVar: ${cssVar},
+        token: {
+          colorPrimary: "${primaryColor}",
+        },
+      }}
+      themeMode={DEFAULT_APPEARANCE}
+    >
+      ${globalReset ? "<GlobalReset />" : ""}
+      {children}
+    </ThemeProvider>
+  );
+}
+
+export default ThemeWrapper;
+`;
+}
+var GLOBAL_RESET_CODE = `
+const GlobalReset = createGlobalStyle\`
+  *,
+  *::before,
+  *::after {
+    box-sizing: border-box;
+  }
+
+  html, body, #root, #app {
+    height: 100%;
+    margin: 0;
+    padding: 0;
+  }
+
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto,
+      "Helvetica Neue", Arial, "Noto Sans", sans-serif;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+\`;
+`;
+var DARK_MODE_EFFECT = `
+  useEffect(() => {
+    if (DEFAULT_APPEARANCE !== "auto") {
+      document.documentElement.dataset.theme = DEFAULT_APPEARANCE;
+      return;
+    }
+
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    document.documentElement.dataset.theme = mediaQuery.matches ? "dark" : "light";
+
+    function handleChange(e: MediaQueryListEvent) {
+      document.documentElement.dataset.theme = e.matches ? "dark" : "light";
+    }
+
+    mediaQuery.addEventListener("change", handleChange);
+    return () => mediaQuery.removeEventListener("change", handleChange);
+  }, []);
+`;
+
+// src/plugin/builtin/mock.ts
+import { resolve as resolve2, join as join9 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+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 = resolve2(cwd, mockDir);
+    if (!existsSync9(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 (!existsSync9(dir)) {
+    return files;
+  }
+  const entries = readdirSync2(dir);
+  for (const entry of entries) {
+    const fullPath = join9(dir, entry);
+    const stat = statSync2(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/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/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,
+    },
+  },
 });
-module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./config/config"), module.exports);
-__reExport(src_exports, require("./route/route"), module.exports);
-var import_generator = require("./service/generator");
-__reExport(src_exports, require("./service/pluginAPI"), module.exports);
-__reExport(src_exports, require("./service/service"), module.exports);
-var import_types = require("./types");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Env,
-  Generator,
-  GeneratorType,
-  IAdd,
-  IEvent,
-  IModify,
-  IRoute,
-  ...require("./config/config"),
-  ...require("./route/route"),
-  ...require("./service/pluginAPI"),
-  ...require("./service/service")
+
+export default queryClient;
+`;
+}
+function buildRequestFile(opts) {
+  const { baseURL, timeout } = opts;
+  return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/plugin-react-query \u81EA\u52A8\u751F\u6210
+import axios, { type AxiosInstance, type AxiosRequestConfig, type InternalAxiosRequestConfig, type AxiosResponse, type AxiosError } from "axios";
+
+/**
+ * Axios \u5B9E\u4F8B
+ *
+ * \u57FA\u7840\u914D\u7F6E\u7531\u63D2\u4EF6\u751F\u6210\uFF0C\u53EF\u5728 src/app.config.ts \u4E2D\u901A\u8FC7
+ * \`configureRequest(request)\` \u81EA\u5B9A\u4E49\u62E6\u622A\u5668\u3002
+ */
+export const request: AxiosInstance = axios.create({
+  baseURL: "${baseURL}" || import.meta.env.VITE_API_BASE_URL || "",
+  timeout: ${timeout},
+  headers: {
+    "Content-Type": "application/json",
+  },
+});
+
+// ============ \u8BF7\u6C42\u62E6\u622A\u5668 ============
+
+request.interceptors.request.use(
+  (config: InternalAxiosRequestConfig) => {
+    // Token \u6CE8\u5165\uFF08\u4ECE localStorage \u8BFB\u53D6\uFF0C\u53EF\u6309\u9700\u66FF\u6362\uFF09
+    const token = typeof localStorage !== "undefined"
+      ? localStorage.getItem("token")
+      : null;
+
+    if (token && config.headers) {
+      config.headers.Authorization = \`Bearer \${token}\`;
+    }
+
+    return config;
+  },
+  (error: AxiosError) => Promise.reject(error)
+);
+
+// ============ \u54CD\u5E94\u62E6\u622A\u5668 ============
+
+request.interceptors.response.use(
+  (response: AxiosResponse) => {
+    // \u76F4\u63A5\u8FD4\u56DE data \u5C42\uFF0C\u51CF\u5C11\u4E1A\u52A1\u4EE3\u7801\u89E3\u6784
+    return response.data;
+  },
+  (error: AxiosError) => {
+    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 404:
+        console.warn("[request] \u8BF7\u6C42\u8D44\u6E90\u4E0D\u5B58\u5728");
+        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);
+  }
+);
+
+export default request;
+`;
+}
+
+// src/plugin/builtin/zustand.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
+import { join as join10 } 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 = join10(cwd, storeDir);
+    if (scaffold && !existsSync10(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,
+    join10(storePath, "middleware"),
+    join10(storePath, "app"),
+    join10(storePath, "app", "slices"),
+    join10(storePath, "app", "slices", "counter")
+  ];
+  for (const dir of dirs) {
+    if (!existsSync10(dir)) {
+      mkdirSync4(dir, { recursive: true });
+    }
+  }
+  writeFileSync5(
+    join10(storePath, "middleware", "createDevtools.ts"),
+    TPL_CREATE_DEVTOOLS,
+    "utf-8"
+  );
+  writeFileSync5(
+    join10(storePath, "app", "slices", "counter", "initialState.ts"),
+    TPL_COUNTER_INITIAL_STATE,
+    "utf-8"
+  );
+  writeFileSync5(
+    join10(storePath, "app", "slices", "counter", "actions.ts"),
+    TPL_COUNTER_ACTIONS,
+    "utf-8"
+  );
+  writeFileSync5(
+    join10(storePath, "app", "initialState.ts"),
+    TPL_APP_INITIAL_STATE,
+    "utf-8"
+  );
+  writeFileSync5(
+    join10(storePath, "app", "store.ts"),
+    TPL_APP_STORE,
+    "utf-8"
+  );
+  writeFileSync5(
+    join10(storePath, "app", "index.tsx"),
+    TPL_APP_INDEX,
+    "utf-8"
+  );
+  writeFileSync5(join10(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/cli/dev.ts
+import { rspack as rspack3 } from "@rspack/core";
+import { RspackDevServer } from "@rspack/dev-server";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/cli/env.ts
+import { existsSync as existsSync11, readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve3 } from "path";
+import dotenv from "dotenv";
+function preloadEnv(cwd, mode) {
+  process.env.NODE_ENV = mode;
+  const defaultPaths = [
+    resolve3(cwd, "config/env/.env.public"),
+    resolve3(cwd, ".env.public"),
+    resolve3(cwd, ".env")
+  ];
+  for (const envPath of defaultPaths) {
+    if (existsSync11(envPath)) {
+      dotenv.config({ path: envPath });
+      break;
+    }
+  }
+  const modeEnvPaths = [
+    resolve3(cwd, `config/env/.env.${mode}`),
+    resolve3(cwd, `.env.${mode}`)
+  ];
+  for (const envPath of modeEnvPaths) {
+    if (existsSync11(envPath)) {
+      const envContent = readFileSync4(envPath, "utf-8");
+      const parsed = dotenv.parse(envContent);
+      for (const key in parsed) {
+        process.env[key] = parsed[key];
+      }
+      break;
+    }
+  }
+}
+function loadEnv(config, cwd, mode) {
+  const { env } = config;
+  const publicEnvPath = resolve3(cwd, env.publicEnvFile ?? "config/env/.env.public");
+  if (existsSync11(publicEnvPath)) {
+    dotenv.config({ path: publicEnvPath });
+  }
+  const modeEnvPath = resolve3(cwd, env.envDir ?? "config/env", `.env.${mode}`);
+  if (existsSync11(modeEnvPath)) {
+    const envContent = readFileSync4(modeEnvPath, "utf-8");
+    const parsed = dotenv.parse(envContent);
+    for (const key in parsed) {
+      process.env[key] = parsed[key];
+    }
+  }
+  process.env.NODE_ENV = mode;
+  process.env.APP_NAME = process.env.APP_NAME || config.appName;
+  process.env.APP_CNAME = process.env.APP_CNAME || config.appCName;
+  process.env.OUTPUT_PATH = process.env.OUTPUT_PATH || config.output.path;
+  process.env.PUBLIC_PATH = process.env.PUBLIC_PATH || config.output.publicPath;
+  process.env.APP_HOST = process.env.APP_HOST || config.dev.host;
+  process.env.APP_PORT = process.env.APP_PORT || String(config.dev.port);
+}
+
+// src/cli/dev.ts
+async function dev(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const spinner = ora("\u6B63\u5728\u542F\u52A8\u5F00\u53D1\u670D\u52A1\u5668...").start();
+  try {
+    preloadEnv(cwd, "development");
+    const { config, configPath } = await resolveConfig(cwd);
+    if (configPath) {
+      spinner.text = `\u5DF2\u52A0\u8F7D\u914D\u7F6E: ${configPath}`;
+    }
+    loadEnv(config, cwd, "development");
+    const pluginManager = new PluginManager(config, cwd, true);
+    if (config.plugins && config.plugins.length > 0) {
+      spinner.text = "\u52A0\u8F7D\u63D2\u4EF6...";
+      await pluginManager.loadPlugins(config.plugins);
+    }
+    await pluginManager.runBeforeDevServer();
+    let rspackConfig = createRspackConfig(config, cwd, { isDev: true });
+    rspackConfig = await pluginManager.applyRspackConfigHooks(rspackConfig);
+    const compiler = rspack3(rspackConfig);
+    const devServerOptions = rspackConfig.devServer || {};
+    const server = new RspackDevServer(devServerOptions, compiler);
+    const host = config.dev.host || "localhost";
+    const port = config.dev.port || 3e3;
+    await server.start();
+    await pluginManager.runAfterDevServer({ host, port });
+    spinner.succeed(chalk.green("\u5F00\u53D1\u670D\u52A1\u5668\u542F\u52A8\u6210\u529F!"));
+    console.log();
+    console.log(
+      `  ${chalk.bold("Local:")}   ${chalk.cyan(`http://${host}:${port}`)}`
+    );
+    const pluginNames = pluginManager.getPluginNames();
+    if (pluginNames.length > 0) {
+      console.log(`  ${chalk.bold("\u63D2\u4EF6:")}    ${chalk.dim(pluginNames.join(", "))}`);
+    }
+    console.log();
+    const signals = ["SIGINT", "SIGTERM"];
+    for (const signal of signals) {
+      process.on(signal, async () => {
+        await server.stop();
+        process.exit(0);
+      });
+    }
+  } catch (error) {
+    spinner.fail(chalk.red("\u5F00\u53D1\u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/cli/build.ts
+import { rspack as rspack4 } from "@rspack/core";
+import chalk2 from "chalk";
+import ora2 from "ora";
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+function printBuildResult(stats) {
+  const info = stats.toJson({
+    assets: true,
+    errors: true,
+    warnings: true
+  });
+  if (info.errors && info.errors.length > 0) {
+    console.log(chalk2.red("\n\u6784\u5EFA\u9519\u8BEF:"));
+    for (const error of info.errors) {
+      console.log(chalk2.red(`  ${error.message}`));
+    }
+    return;
+  }
+  if (info.warnings && info.warnings.length > 0) {
+    console.log(chalk2.yellow("\n\u6784\u5EFA\u8B66\u544A:"));
+    for (const warning of info.warnings) {
+      console.log(chalk2.yellow(`  ${warning.message}`));
+    }
+  }
+  console.log(chalk2.bold("\n\u6784\u5EFA\u4EA7\u7269:"));
+  console.log();
+  const assets = info.assets || [];
+  const sortedAssets = assets.filter((asset) => !asset.name.endsWith(".map")).sort((a, b) => b.size - a.size);
+  for (const asset of sortedAssets.slice(0, 15)) {
+    const sizeColor = asset.size > 500 * 1024 ? chalk2.yellow : chalk2.green;
+    console.log(
+      `  ${chalk2.dim(asset.name.padEnd(50))} ${sizeColor(formatSize(asset.size))}`
+    );
+  }
+  if (sortedAssets.length > 15) {
+    console.log(chalk2.dim(`  ... \u8FD8\u6709 ${sortedAssets.length - 15} \u4E2A\u6587\u4EF6`));
+  }
+  console.log();
+  console.log(
+    chalk2.green(
+      `\u2713 \u6784\u5EFA\u5B8C\u6210\uFF0C\u8017\u65F6 ${((info.time || 0) / 1e3).toFixed(2)}s`
+    )
+  );
+}
+async function build(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const spinner = ora2("\u6B63\u5728\u6784\u5EFA\u751F\u4EA7\u73AF\u5883...").start();
+  try {
+    preloadEnv(cwd, "production");
+    const { config, configPath } = await resolveConfig(cwd);
+    if (configPath) {
+      spinner.text = `\u5DF2\u52A0\u8F7D\u914D\u7F6E: ${configPath}`;
+    }
+    loadEnv(config, cwd, "production");
+    const pluginManager = new PluginManager(config, cwd, false);
+    if (config.plugins && config.plugins.length > 0) {
+      spinner.text = "\u52A0\u8F7D\u63D2\u4EF6...";
+      await pluginManager.loadPlugins(config.plugins);
+    }
+    await pluginManager.runBeforeBuild();
+    let rspackConfig = createRspackConfig(config, cwd, { isDev: false });
+    rspackConfig = await pluginManager.applyRspackConfigHooks(rspackConfig);
+    spinner.text = "\u6B63\u5728\u7F16\u8BD1...";
+    const compiler = rspack4(rspackConfig);
+    const stats = await new Promise((resolve4, reject) => {
+      compiler.run((err, stats2) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        if (!stats2) {
+          reject(new Error("\u6784\u5EFA\u5931\u8D25: \u65E0\u6CD5\u83B7\u53D6\u7EDF\u8BA1\u4FE1\u606F"));
+          return;
+        }
+        resolve4(stats2);
+      });
+    });
+    await new Promise((resolve4, reject) => {
+      compiler.close((err) => {
+        if (err) reject(err);
+        else resolve4();
+      });
+    });
+    const hasErrors = stats.hasErrors();
+    const statsInfo = stats.toJson({ errors: true });
+    await pluginManager.runAfterBuild({
+      success: !hasErrors,
+      errors: statsInfo.errors?.map((e) => e.message)
+    });
+    if (hasErrors) {
+      spinner.fail(chalk2.red("\u6784\u5EFA\u5931\u8D25"));
+      printBuildResult(stats);
+      process.exit(1);
+    }
+    spinner.succeed(chalk2.green("\u6784\u5EFA\u5B8C\u6210!"));
+    printBuildResult(stats);
+  } catch (error) {
+    spinner.fail(chalk2.red("\u6784\u5EFA\u5931\u8D25"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+export {
+  AppContext,
+  AppContextProvider,
+  ConventionalRouteGenerator,
+  ConventionalRoutePlugin,
+  ErrorBoundary,
+  PluginManager,
+  RootProvider,
+  YwkfGenerator,
+  YwkfGeneratorPlugin,
+  analyticsPlugin,
+  bootstrap,
+  build,
+  createBaseConfig,
+  createDevConfig,
+  createMicroApp,
+  createPlugin,
+  createProdConfig,
+  createProvider,
+  createRspackConfig,
+  defaultConfig,
+  defineConfig,
+  definePlugin,
+  dev,
+  garfishPlugin,
+  generateConventionalRoutes,
+  getMicroAppPublicPath,
+  i18nPlugin,
+  isMicroAppEnv,
+  mockPlugin,
+  reactQueryPlugin,
+  tailwindPlugin,
+  themePlugin,
+  unmount,
+  useApp,
+  useAppName,
+  useBasename,
+  useEnv,
+  useIsDev,
+  zustandPlugin
+};
+//# sourceMappingURL=index.js.map